PGCodeLLM/FEA-Bench-v1.0-Standard · Datasets at Hugging Face

instance_id stringlengths 13 45	pull_number int64 7 30.1k	repo stringclasses 83 values	version stringclasses 68 values	base_commit stringlengths 40 40	created_at stringdate 2013-05-16 18:15:55 2025-01-08 15:12:50	patch stringlengths 347 35.2k	test_patch stringlengths 432 113k	non_py_patch stringlengths 0 18.3k	new_components listlengths 0 40	FAIL_TO_PASS listlengths 1 2.53k	PASS_TO_PASS listlengths 0 1.7k	problem_statement stringlengths 607 52.7k	hints_text stringlengths 0 57.4k	environment_setup_commit stringclasses 167 values
pvlib__pvlib-python-784	784	pvlib/pvlib-python	0.6	e94d9238a8c6eacee57e03f4a4fa267673f941f3	2019-10-02T23:52:22Z	diff --git a/docs/sphinx/source/api.rst b/docs/sphinx/source/api.rst index c37bedf7df..26786d4f88 100644 --- a/docs/sphinx/source/api.rst +++ b/docs/sphinx/source/api.rst @@ -303,6 +303,7 @@ Functions for fitting PV models ivtools.fit_sde_sandia ivtools.fit_sdm_cec_sam + ivtools.fit_sdm_desoto Other ----- diff --git a/docs/sphinx/source/whatsnew/v0.7.0.rst b/docs/sphinx/source/whatsnew/v0.7.0.rst index 2b65b17a9e..fdc419ef6e 100644 --- a/docs/sphinx/source/whatsnew/v0.7.0.rst +++ b/docs/sphinx/source/whatsnew/v0.7.0.rst @@ -1,4 +1,4 @@ -.. _whatsnew_0700: +.. _whatsnew_0700: v0.7.0 (MONTH DAY, YEAR) ------------------------ @@ -111,6 +111,8 @@ Enhancements the single diode equation to an IV curve. * Add :py:func:`~pvlib.ivtools.fit_sdm_cec_sam`, a wrapper for the CEC single diode model fitting function '6parsolve' from NREL's System Advisor Model. +* Add :py:func:`~pvlib.ivtools.fit_sdm_desoto`, a method to fit the De Soto single + diode model to the typical specifications given in manufacturers datasheets. * Add `timeout` to :py:func:`pvlib.iotools.get_psm3`. Bug fixes @@ -162,4 +164,5 @@ Contributors * Anton Driesse (:ghuser:`adriesse`) * Alexander Morgan (:ghuser:`alexandermorgan`) * Miguel Sánchez de León Peque (:ghuser:`Peque`) +* Tanguy Lunel (:ghuser:`tylunel`) * Veronica Guo (:ghuser:`veronicaguo`) diff --git a/pvlib/ivtools.py b/pvlib/ivtools.py index 353a0b8a9a..4806b2ed16 100644 --- a/pvlib/ivtools.py +++ b/pvlib/ivtools.py @@ -262,6 +262,147 @@ def fit_sde_sandia(voltage, current, v_oc=None, i_sc=None, v_mp_i_mp=None, v_oc) +def fit_sdm_desoto(v_mp, i_mp, v_oc, i_sc, alpha_sc, beta_voc, + cells_in_series, EgRef=1.121, dEgdT=-0.0002677, + temp_ref=25, irrad_ref=1000, root_kwargs={}): + """ + Calculates the parameters for the De Soto single diode model using the + procedure described in [1]. This procedure has the advantage of + using common specifications given by manufacturers in the + datasheets of PV modules. + + The solution is found using the scipy.optimize.root() function, + with the corresponding default solver method 'hybr'. + No restriction is put on the fit variables, i.e. series + or shunt resistance could go negative. Nevertheless, if it happens, + check carefully the inputs and their units; alpha_sc and beta_voc are + often given in %/K in manufacturers datasheets and should be given + in A/K and V/K here. + + The parameters returned by this function can be used by + pvsystem.calcparams_desoto to calculate the values at different + irradiance and cell temperature. + + Parameters + ---------- + v_mp: float + Module voltage at the maximum-power point at reference conditions [V]. + i_mp: float + Module current at the maximum-power point at reference conditions [A]. + v_oc: float + Open-circuit voltage at reference conditions [V]. + i_sc: float + Short-circuit current at reference conditions [A]. + alpha_sc: float + The short-circuit current (i_sc) temperature coefficient of the + module [A/K]. + beta_voc: float + The open-circuit voltage (v_oc) temperature coefficient of the + module [V/K]. + cells_in_series: integer + Number of cell in the module. + EgRef: float, default 1.121 eV - value for silicon + Energy of bandgap of semi-conductor used [eV] + dEgdT: float, default -0.0002677 - value for silicon + Variation of bandgap according to temperature [eV/K] + temp_ref: float, default 25 + Reference temperature condition [C] + irrad_ref: float, default 1000 + Reference irradiance condition [W/m2] + root_kwargs: dictionary, default None + Dictionary of arguments to pass onto scipy.optimize.root() + + Returns + ------- + Tuple of the following elements: + + * Dictionary with the following elements: + I_L_ref: float + Light-generated current at reference conditions [A] + I_o_ref: float + Diode saturation current at reference conditions [A] + R_s: float + Series resistance [ohms] + R_sh_ref: float + Shunt resistance at reference conditions [ohms]. + a_ref: float + Modified ideality factor at reference conditions. + The product of the usual diode ideality factor (n, unitless), + number of cells in series (Ns), and cell thermal voltage at + specified effective irradiance and cell temperature. + alpha_sc: float + The short-circuit current (i_sc) temperature coefficient of the + module [A/K]. + EgRef: float + Energy of bandgap of semi-conductor used [eV] + dEgdT: float + Variation of bandgap according to temperature [eV/K] + irrad_ref: float + Reference irradiance condition [W/m2] + temp_ref: float + Reference temperature condition [C] + * scipy.optimize.OptimizeResult + Optimization result of scipy.optimize.root(). + See scipy.optimize.OptimizeResult for more details. + + References + ---------- + [1] W. De Soto et al., "Improvement and validation of a model for + photovoltaic array performance", Solar Energy, vol 80, pp. 78-88, + 2006. + + [2] John A Dufﬁe, William A Beckman, "Solar Engineering of Thermal + Processes", Wiley, 2013 + """ + + try: + from scipy.optimize import root + from scipy import constants + except ImportError: + raise ImportError("The fit_sdm_desoto function requires scipy.") + + # Constants + k = constants.value('Boltzmann constant in eV/K') + Tref = temp_ref + 273.15 # [K] + + # initial guesses of variables for computing convergence: + # Values are taken from [2], p753 + Rsh_0 = 100.0 + a_0 = 1.5kTrefcells_in_series + IL_0 = i_sc + Io_0 = i_sc np.exp(-v_oc/a_0) + Rs_0 = (a_0np.log1p((IL_0-i_mp)/Io_0) - v_mp)/i_mp + # params_i : initial values vector + params_i = np.array([IL_0, Io_0, a_0, Rsh_0, Rs_0]) + + # specs of module + specs = (i_sc, v_oc, i_mp, v_mp, beta_voc, alpha_sc, EgRef, dEgdT, + Tref, k) + + # computing with system of equations described in [1] + optimize_result = root(_system_of_equations_desoto, x0=params_i, + args=(specs,), root_kwargs) + + if optimize_result.success: + sdm_params = optimize_result.x + else: + raise RuntimeError( + 'Parameter estimation failed:\n' + optimize_result.message) + + # results + return ({'I_L_ref': sdm_params[0], + 'I_o_ref': sdm_params[1], + 'a_ref': sdm_params[2], + 'R_sh_ref': sdm_params[3], + 'R_s': sdm_params[4], + 'alpha_sc': alpha_sc, + 'EgRef': EgRef, + 'dEgdT': dEgdT, + 'irrad_ref': irrad_ref, + 'temp_ref': temp_ref}, + optimize_result) + + def _find_mp(voltage, current): """ Finds voltage and current at maximum power point. @@ -348,3 +489,69 @@ def _calculate_sde_parameters(beta0, beta1, beta3, beta4, v_mp, i_mp, v_oc): else: # I0_voc > 0 I0 = I0_voc return (IL, I0, Rsh, Rs, nNsVth) + + +def _system_of_equations_desoto(params, specs): + """Evaluates the systems of equations used to solve for the single + diode equation parameters. Function designed to be used by + scipy.optimize.root() in fit_sdm_desoto(). + + Parameters + ---------- + params: ndarray + Array with parameters of the De Soto single diode model. Must be + given in the following order: IL, Io, a, Rsh, Rs + specs: tuple + Specifications of pv module given by manufacturer. Must be given + in the following order: Isc, Voc, Imp, Vmp, beta_oc, alpha_sc + + Returns + ------- + system of equations to solve with scipy.optimize.root(). + + + References + ---------- + [1] W. De Soto et al., "Improvement and validation of a model for + photovoltaic array performance", Solar Energy, vol 80, pp. 78-88, + 2006. + + [2] John A Dufﬁe, William A Beckman, "Solar Engineering of Thermal + Processes", Wiley, 2013 + """ + + # six input known variables + Isc, Voc, Imp, Vmp, beta_oc, alpha_sc, EgRef, dEgdT, Tref, k = specs + + # five parameters vector to find + IL, Io, a, Rsh, Rs = params + + # five equation vector + y = [0, 0, 0, 0, 0] + + # 1st equation - short-circuit - eq(3) in [1] + y[0] = Isc - IL + Io np.expm1(Isc * Rs / a) + Isc * Rs / Rsh + + # 2nd equation - open-circuit Tref - eq(4) in [1] + y[1] = -IL + Io * np.expm1(Voc / a) + Voc / Rsh + + # 3rd equation - Imp & Vmp - eq(5) in [1] + y[2] = Imp - IL + Io * np.expm1((Vmp + Imp * Rs) / a) \ + + (Vmp + Imp * Rs) / Rsh + + # 4th equation - Pmp derivated=0 - eq23.2.6 in [2] + # caution: eq(6) in [1] has a sign error + y[3] = Imp \ + - Vmp * ((Io / a) * np.exp((Vmp + Imp * Rs) / a) + 1.0 / Rsh) \ + / (1.0 + (Io * Rs / a) * np.exp((Vmp + Imp * Rs) / a) + Rs / Rsh) + + # 5th equation - open-circuit T2 - eq (4) at temperature T2 in [1] + T2 = Tref + 2 + Voc2 = (T2 - Tref) * beta_oc + Voc # eq (7) in [1] + a2 = a * T2 / Tref # eq (8) in [1] + IL2 = IL + alpha_sc * (T2 - Tref) # eq (11) in [1] + Eg2 = EgRef * (1 + dEgdT * (T2 - Tref)) # eq (10) in [1] + Io2 = Io * (T2 / Tref)*3 np.exp(1 / k * (EgRef/Tref - Eg2/T2)) # eq (9) + y[4] = -IL2 + Io2 * np.expm1(Voc2 / a2) + Voc2 / Rsh # eq (4) at T2 + + return y	diff --git a/pvlib/test/test_ivtools.py b/pvlib/test/test_ivtools.py index d4aca050c4..6f9fdd6fec 100644 --- a/pvlib/test/test_ivtools.py +++ b/pvlib/test/test_ivtools.py @@ -102,6 +102,35 @@ def test_fit_sdm_cec_sam(get_cec_params_cansol_cs5p_220p): cells_in_series=1, temp_ref=25) +@requires_scipy +def test_fit_sdm_desoto(): + result, _ = ivtools.fit_sdm_desoto(v_mp=31.0, i_mp=8.71, v_oc=38.3, + i_sc=9.43, alpha_sc=0.005658, + beta_voc=-0.13788, + cells_in_series=60) + result_expected = {'I_L_ref': 9.45232, + 'I_o_ref': 3.22460e-10, + 'a_ref': 1.59128, + 'R_sh_ref': 125.798, + 'R_s': 0.297814, + 'alpha_sc': 0.005658, + 'EgRef': 1.121, + 'dEgdT': -0.0002677, + 'irrad_ref': 1000, + 'temp_ref': 25} + assert np.allclose(pd.Series(result), pd.Series(result_expected), + rtol=1e-4) + + +@requires_scipy +def test_fit_sdm_desoto_failure(): + with pytest.raises(RuntimeError) as exc: + ivtools.fit_sdm_desoto(v_mp=31.0, i_mp=8.71, v_oc=38.3, i_sc=9.43, + alpha_sc=0.005658, beta_voc=-0.13788, + cells_in_series=10) + assert ('Parameter estimation failed') in str(exc.value) + + @pytest.fixture def get_bad_iv_curves(): # v1, i1 produces a bad value for I0_voc	diff --git a/docs/sphinx/source/api.rst b/docs/sphinx/source/api.rst index c37bedf7df..26786d4f88 100644 --- a/docs/sphinx/source/api.rst +++ b/docs/sphinx/source/api.rst @@ -303,6 +303,7 @@ Functions for fitting PV models ivtools.fit_sde_sandia ivtools.fit_sdm_cec_sam + ivtools.fit_sdm_desoto Other ----- diff --git a/docs/sphinx/source/whatsnew/v0.7.0.rst b/docs/sphinx/source/whatsnew/v0.7.0.rst index 2b65b17a9e..fdc419ef6e 100644 --- a/docs/sphinx/source/whatsnew/v0.7.0.rst +++ b/docs/sphinx/source/whatsnew/v0.7.0.rst @@ -1,4 +1,4 @@ -.. _whatsnew_0700: +.. _whatsnew_0700: v0.7.0 (MONTH DAY, YEAR) ------------------------ @@ -111,6 +111,8 @@ Enhancements the single diode equation to an IV curve. * Add :py:func:`~pvlib.ivtools.fit_sdm_cec_sam`, a wrapper for the CEC single diode model fitting function '6parsolve' from NREL's System Advisor Model. +* Add :py:func:`~pvlib.ivtools.fit_sdm_desoto`, a method to fit the De Soto single + diode model to the typical specifications given in manufacturers datasheets. * Add `timeout` to :py:func:`pvlib.iotools.get_psm3`. Bug fixes @@ -162,4 +164,5 @@ Contributors * Anton Driesse (:ghuser:`adriesse`) * Alexander Morgan (:ghuser:`alexandermorgan`) * Miguel Sánchez de León Peque (:ghuser:`Peque`) +* Tanguy Lunel (:ghuser:`tylunel`) * Veronica Guo (:ghuser:`veronicaguo`)	[ { "components": [ { "doc": "Calculates the parameters for the De Soto single diode model using the\nprocedure described in [1]. This procedure has the advantage of\nusing common specifications given by manufacturers in the\ndatasheets of PV modules.\n\nThe solution is found using the scipy.optimiz...	[ "pvlib/test/test_ivtools.py::test_fit_sdm_desoto", "pvlib/test/test_ivtools.py::test_fit_sdm_desoto_failure" ]	[ "pvlib/test/test_ivtools.py::test_fit_sde_sandia", "pvlib/test/test_ivtools.py::test_fit_sde_sandia_bad_iv", "pvlib/test/test_ivtools.py::test_fit_sdm_cec_sam" ]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> coefficient estimation method following DeSoto(2006) - [x] I am familiar with the [contributing guidelines](http://pvlib-python.readthedocs.io/en/latest/contributing.html). - [x] Fully tested. Added and/or modified tests to ensure correct behavior for all reasonable inputs. Tests (usually) must pass on the TravisCI and Appveyor testing services. - [x] Updates entries to `docs/sphinx/source/api.rst` for API changes. - [x] Adds description and name entries in the appropriate `docs/sphinx/source/whatsnew` file for all changes. - [x] Code quality and style is sufficient. Passes LGTM and SticklerCI checks. - [x] New code is fully documented. Includes sphinx/numpydoc compliant docstrings and comments in the code where necessary. - [x] Pull request is nearly complete and ready for detailed review. Brief description of the problem and proposed solution: This function computes the 5 sdm parameters coefficients following the procedure proposed by W. De Soto et al., "Improvement and validation of a model for photovoltaic array performance", Solar Energy, vol80, pp. 78-88, 2006. In my opinion the function has the advantage to be transparent for python users and can be used with standard specifications found in manucfacturer datasheets. Please just state your interest or not in this function and, if you are interested, I will complete it so as to check all the conditions then. This is my first pull request so don't hesitate to give me any feedback you think useful, thanks ! ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pvlib/ivtools.py] (definition of fit_sdm_desoto:) def fit_sdm_desoto(v_mp, i_mp, v_oc, i_sc, alpha_sc, beta_voc, cells_in_series, EgRef=1.121, dEgdT=-0.0002677, temp_ref=25, irrad_ref=1000, root_kwargs={}): """Calculates the parameters for the De Soto single diode model using the procedure described in [1]. This procedure has the advantage of using common specifications given by manufacturers in the datasheets of PV modules. The solution is found using the scipy.optimize.root() function, with the corresponding default solver method 'hybr'. No restriction is put on the fit variables, i.e. series or shunt resistance could go negative. Nevertheless, if it happens, check carefully the inputs and their units; alpha_sc and beta_voc are often given in %/K in manufacturers datasheets and should be given in A/K and V/K here. The parameters returned by this function can be used by pvsystem.calcparams_desoto to calculate the values at different irradiance and cell temperature. Parameters ---------- v_mp: float Module voltage at the maximum-power point at reference conditions [V]. i_mp: float Module current at the maximum-power point at reference conditions [A]. v_oc: float Open-circuit voltage at reference conditions [V]. i_sc: float Short-circuit current at reference conditions [A]. alpha_sc: float The short-circuit current (i_sc) temperature coefficient of the module [A/K]. beta_voc: float The open-circuit voltage (v_oc) temperature coefficient of the module [V/K]. cells_in_series: integer Number of cell in the module. EgRef: float, default 1.121 eV - value for silicon Energy of bandgap of semi-conductor used [eV] dEgdT: float, default -0.0002677 - value for silicon Variation of bandgap according to temperature [eV/K] temp_ref: float, default 25 Reference temperature condition [C] irrad_ref: float, default 1000 Reference irradiance condition [W/m2] root_kwargs: dictionary, default None Dictionary of arguments to pass onto scipy.optimize.root() Returns ------- Tuple of the following elements: * Dictionary with the following elements: I_L_ref: float Light-generated current at reference conditions [A] I_o_ref: float Diode saturation current at reference conditions [A] R_s: float Series resistance [ohms] R_sh_ref: float Shunt resistance at reference conditions [ohms]. a_ref: float Modified ideality factor at reference conditions. The product of the usual diode ideality factor (n, unitless), number of cells in series (Ns), and cell thermal voltage at specified effective irradiance and cell temperature. alpha_sc: float The short-circuit current (i_sc) temperature coefficient of the module [A/K]. EgRef: float Energy of bandgap of semi-conductor used [eV] dEgdT: float Variation of bandgap according to temperature [eV/K] irrad_ref: float Reference irradiance condition [W/m2] temp_ref: float Reference temperature condition [C] * scipy.optimize.OptimizeResult Optimization result of scipy.optimize.root(). See scipy.optimize.OptimizeResult for more details. References ---------- [1] W. De Soto et al., "Improvement and validation of a model for photovoltaic array performance", Solar Energy, vol 80, pp. 78-88, 2006. [2] John A Dufﬁe, William A Beckman, "Solar Engineering of Thermal Processes", Wiley, 2013""" (definition of _system_of_equations_desoto:) def _system_of_equations_desoto(params, specs): """Evaluates the systems of equations used to solve for the single diode equation parameters. Function designed to be used by scipy.optimize.root() in fit_sdm_desoto(). Parameters ---------- params: ndarray Array with parameters of the De Soto single diode model. Must be given in the following order: IL, Io, a, Rsh, Rs specs: tuple Specifications of pv module given by manufacturer. Must be given in the following order: Isc, Voc, Imp, Vmp, beta_oc, alpha_sc Returns ------- system of equations to solve with scipy.optimize.root(). References ---------- [1] W. De Soto et al., "Improvement and validation of a model for photovoltaic array performance", Solar Energy, vol 80, pp. 78-88, 2006. [2] John A Dufﬁe, William A Beckman, "Solar Engineering of Thermal Processes", Wiley, 2013""" [end of new definitions in pvlib/ivtools.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		7fc595a13bcd42e3269c0806f5505ac907af9730
sympy__sympy-17677	17,677	sympy/sympy	1.5	0ace745eac76d054af75f3d578b9d567e3581a80	2019-10-01T09:21:18Z	diff --git a/sympy/combinatorics/perm_groups.py b/sympy/combinatorics/perm_groups.py index d854935efa6e..ebc41adef4b6 100644 --- a/sympy/combinatorics/perm_groups.py +++ b/sympy/combinatorics/perm_groups.py @@ -1873,6 +1873,73 @@ def is_elementary(self, p): """ return self.is_abelian and all(g.order() == p for g in self.generators) + def _eval_is_alt_sym_naive(self, only_sym=False, only_alt=False): + """A naive test using the group order.""" + if only_sym and only_alt: + raise ValueError( + "Both {} and {} cannot be set to True" + .format(only_sym, only_alt)) + + n = self.degree + sym_order = 1 + for i in range(2, n+1): + sym_order = i + order = self.order() + + if order == sym_order: + self._is_sym = True + self._is_alt = False + if only_alt: + return False + return True + + elif 2order == sym_order: + self._is_sym = False + self._is_alt = True + if only_sym: + return False + return True + + return False + + def _eval_is_alt_sym_monte_carlo(self, eps=0.05, perms=None): + """A test using monte-carlo algorithm. + + Parameters + ========== + + eps : float, optional + The criterion for the incorrect ``False`` return. + + perms : list[Permutation], optional + If explicitly given, it tests over the given candidats + for testing. + + If ``None``, it randomly computes ``N_eps`` and chooses + ``N_eps`` sample of the permutation from the group. + + See Also + ======== + + _check_cycles_alt_sym + """ + if perms is None: + n = self.degree + if n < 17: + c_n = 0.34 + else: + c_n = 0.57 + d_n = (c_nlog(2))/log(n) + N_eps = int(-log(eps)/d_n) + + perms = (self.random_pr() for i in range(N_eps)) + return self._eval_is_alt_sym_monte_carlo(perms=perms) + + for perm in perms: + if _check_cycles_alt_sym(perm): + return True + return False + def is_alt_sym(self, eps=0.05, _random_prec=None): r"""Monte Carlo test for the symmetric/alternating group for degrees >= 8. @@ -1913,42 +1980,25 @@ def is_alt_sym(self, eps=0.05, _random_prec=None): _check_cycles_alt_sym """ - if _random_prec is None: - if self._is_sym or self._is_alt: - return True - n = self.degree - if n < 8: - sym_order = 1 - for i in range(2, n+1): - sym_order = i - order = self.order() - if order == sym_order: - self._is_sym = True - return True - elif 2order == sym_order: - self._is_alt = True - return True - return False - if not self.is_transitive(): - return False - if n < 17: - c_n = 0.34 - else: - c_n = 0.57 - d_n = (c_nlog(2))/log(n) - N_eps = int(-log(eps)/d_n) - for i in range(N_eps): - perm = self.random_pr() - if _check_cycles_alt_sym(perm): - return True - return False - else: - for i in range(_random_prec['N_eps']): - perm = _random_prec[i] - if _check_cycles_alt_sym(perm): - return True + if _random_prec is not None: + N_eps = _random_prec['N_eps'] + perms= (_random_prec[i] for i in range(N_eps)) + return self._eval_is_alt_sym_monte_carlo(perms=perms) + + if self._is_sym or self._is_alt: + return True + if self._is_sym is False and self._is_alt is False: return False + n = self.degree + if n < 8: + return self._eval_is_alt_sym_naive() + elif self.is_transitive(): + return self._eval_is_alt_sym_monte_carlo(eps=eps) + + self._is_sym, self._is_alt = False, False + return False + @property def is_nilpotent(self): """Test if the group is nilpotent. @@ -2820,6 +2870,123 @@ def index(self, H): if H.is_subgroup(self): return self.order()//H.order() + @property + def is_symmetric(self): + """Return ``True`` if the group is symmetric. + + Examples + ======== + + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> g = SymmetricGroup(5) + >>> g.is_symmetric + True + + >>> from sympy.combinatorics import Permutation, PermutationGroup + >>> g = PermutationGroup( + ... Permutation(0, 1, 2, 3, 4), + ... Permutation(2, 3)) + >>> g.is_symmetric + True + + Notes + ===== + + This uses a naive test involving the computation of the full + group order. + If you need more quicker taxonomy for large groups, you can use + :meth:`PermutationGroup.is_alt_sym`. + However, :meth:`PermutationGroup.is_alt_sym` may not be accurate + and is not able to distinguish between an alternating group and + a symmetric group. + + See Also + ======== + + is_alt_sym + """ + _is_sym = self._is_sym + if _is_sym is not None: + return _is_sym + + n = self.degree + if n >= 8: + if self.is_transitive(): + _is_alt_sym = self._eval_is_alt_sym_monte_carlo() + if _is_alt_sym: + if any(g.is_odd for g in self.generators): + self._is_sym, self._is_alt = True, False + return True + + self._is_sym, self._is_alt = False, True + return False + + return self._eval_is_alt_sym_naive(only_sym=True) + + self._is_sym, self._is_alt = False, False + return False + + return self._eval_is_alt_sym_naive(only_sym=True) + + + @property + def is_alternating(self): + """Return ``True`` if the group is alternating. + + Examples + ======== + + >>> from sympy.combinatorics.named_groups import AlternatingGroup + >>> g = AlternatingGroup(5) + >>> g.is_alternating + True + + >>> from sympy.combinatorics import Permutation, PermutationGroup + >>> g = PermutationGroup( + ... Permutation(0, 1, 2, 3, 4), + ... Permutation(2, 3, 4)) + >>> g.is_alternating + True + + Notes + ===== + + This uses a naive test involving the computation of the full + group order. + If you need more quicker taxonomy for large groups, you can use + :meth:`PermutationGroup.is_alt_sym`. + However, :meth:`PermutationGroup.is_alt_sym` may not be accurate + and is not able to distinguish between an alternating group and + a symmetric group. + + See Also + ======== + + is_alt_sym + """ + _is_alt = self._is_alt + if _is_alt is not None: + return _is_alt + + n = self.degree + if n >= 8: + if self.is_transitive(): + _is_alt_sym = self._eval_is_alt_sym_monte_carlo() + if _is_alt_sym: + if all(g.is_even for g in self.generators): + self._is_sym, self._is_alt = False, True + return True + + self._is_sym, self._is_alt = True, False + return False + + return self._eval_is_alt_sym_naive(only_alt=True) + + self._is_sym, self._is_alt = False, False + return False + + return self._eval_is_alt_sym_naive(only_alt=True) + @property def is_cyclic(self): """	diff --git a/sympy/combinatorics/tests/test_perm_groups.py b/sympy/combinatorics/tests/test_perm_groups.py index da2922c845a7..7426a062651d 100644 --- a/sympy/combinatorics/tests/test_perm_groups.py +++ b/sympy/combinatorics/tests/test_perm_groups.py @@ -437,7 +437,15 @@ def test_random_pr(): def test_is_alt_sym(): G = DihedralGroup(10) assert G.is_alt_sym() is False + assert G._eval_is_alt_sym_naive() is False + assert G._eval_is_alt_sym_naive(only_alt=True) is False + assert G._eval_is_alt_sym_naive(only_sym=True) is False + S = SymmetricGroup(10) + assert S._eval_is_alt_sym_naive() is True + assert S._eval_is_alt_sym_naive(only_alt=True) is False + assert S._eval_is_alt_sym_naive(only_sym=True) is True + N_eps = 10 _random_prec = {'N_eps': N_eps, 0: Permutation([[2], [1, 4], [0, 6, 7, 8, 9, 3, 5]]), @@ -451,7 +459,12 @@ def test_is_alt_sym(): 8: Permutation([[1, 5, 6, 3], [0, 2, 7, 8, 4, 9]]), 9: Permutation([[8], [6, 7], [2, 3, 4, 5], [0, 1, 9]])} assert S.is_alt_sym(_random_prec=_random_prec) is True + A = AlternatingGroup(10) + assert A._eval_is_alt_sym_naive() is True + assert A._eval_is_alt_sym_naive(only_alt=True) is True + assert A._eval_is_alt_sym_naive(only_sym=True) is False + _random_prec = {'N_eps': N_eps, 0: Permutation([[1, 6, 4, 2, 7, 8, 5, 9, 3], [0]]), 1: Permutation([[1], [0, 5, 8, 4, 9, 2, 3, 6, 7]]), @@ -465,6 +478,23 @@ def test_is_alt_sym(): 9: Permutation([[4, 9, 6], [3, 8], [1, 2], [0, 5, 7]])} assert A.is_alt_sym(_random_prec=_random_prec) is False + G = PermutationGroup( + Permutation(1, 3, size=8)(0, 2, 4, 6), + Permutation(5, 7, size=8)(0, 2, 4, 6)) + assert G.is_alt_sym() is False + + # Tests for monte-carlo c_n parameter setting, and which guarantees + # to give False. + G = DihedralGroup(10) + assert G._eval_is_alt_sym_monte_carlo() is False + G = DihedralGroup(20) + assert G._eval_is_alt_sym_monte_carlo() is False + + # A dry-running test to check if it looks up for the updated cache. + G = DihedralGroup(6) + G.is_alt_sym() + assert G.is_alt_sym() == False + def test_minimal_block(): D = DihedralGroup(6) @@ -1013,3 +1043,17 @@ def test_composition_series(): assert is_isomorphic(series[1], CyclicGroup(4)) assert is_isomorphic(series[2], CyclicGroup(2)) assert series[3].is_trivial + + +def test_is_symmetric(): + a = Permutation(0, 1, 2) + b = Permutation(0, 1, size=3) + assert PermutationGroup(a, b).is_symmetric == True + + a = Permutation(0, 2, 1) + b = Permutation(1, 2, size=3) + assert PermutationGroup(a, b).is_symmetric == True + + a = Permutation(0, 1, 2, 3) + b = Permutation(0, 3)(1, 2) + assert PermutationGroup(a, b).is_symmetric == False		[ { "components": [ { "doc": "A naive test using the group order.", "lines": [ 1876, 1903 ], "name": "PermutationGroup._eval_is_alt_sym_naive", "signature": "def _eval_is_alt_sym_naive(self, only_sym=False, only_alt=False):", "type": "funct...	[ "test_is_alt_sym" ]	[ "test_has", "test_generate", "test_order", "test_equality", "test_stabilizer", "test_center", "test_centralizer", "test_coset_rank", "test_coset_factor", "test_orbits", "test_is_normal", "test_eq", "test_derived_subgroup", "test_is_solvable", "test_rubik1", "test_direct_product", "te...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add is_symmetric for permutation groups <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed I think that `is_symmetric` predicate is missing even if `_is_sym` cache is used in permutation groups. I've used a naive test that the symmetric group is the largest permutation group that can be created from a base set of cardinality `n`, and have an order of `n!`. #### Other comments I think that permutation group is using custom cache for assumptions. But if there is a way to directly manipulate the global LRU cache or assumptions0 cache if some predicates are revealed during the computation, it may have to use those. #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - combinatorics - Added a new predicate `is_symmetric` to test out if a permutation group is a symmetric group. - Added a new predicate `is_alternating` to test out if a permutation group is a alternating group. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/combinatorics/perm_groups.py] (definition of PermutationGroup._eval_is_alt_sym_naive:) def _eval_is_alt_sym_naive(self, only_sym=False, only_alt=False): """A naive test using the group order.""" (definition of PermutationGroup._eval_is_alt_sym_monte_carlo:) def _eval_is_alt_sym_monte_carlo(self, eps=0.05, perms=None): """A test using monte-carlo algorithm. Parameters ========== eps : float, optional The criterion for the incorrect ``False`` return. perms : list[Permutation], optional If explicitly given, it tests over the given candidats for testing. If ``None``, it randomly computes ``N_eps`` and chooses ``N_eps`` sample of the permutation from the group. See Also ======== _check_cycles_alt_sym""" (definition of PermutationGroup.is_symmetric:) def is_symmetric(self): """Return ``True`` if the group is symmetric. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> g = SymmetricGroup(5) >>> g.is_symmetric True >>> from sympy.combinatorics import Permutation, PermutationGroup >>> g = PermutationGroup( ... Permutation(0, 1, 2, 3, 4), ... Permutation(2, 3)) >>> g.is_symmetric True Notes ===== This uses a naive test involving the computation of the full group order. If you need more quicker taxonomy for large groups, you can use :meth:`PermutationGroup.is_alt_sym`. However, :meth:`PermutationGroup.is_alt_sym` may not be accurate and is not able to distinguish between an alternating group and a symmetric group. See Also ======== is_alt_sym""" (definition of PermutationGroup.is_alternating:) def is_alternating(self): """Return ``True`` if the group is alternating. Examples ======== >>> from sympy.combinatorics.named_groups import AlternatingGroup >>> g = AlternatingGroup(5) >>> g.is_alternating True >>> from sympy.combinatorics import Permutation, PermutationGroup >>> g = PermutationGroup( ... Permutation(0, 1, 2, 3, 4), ... Permutation(2, 3, 4)) >>> g.is_alternating True Notes ===== This uses a naive test involving the computation of the full group order. If you need more quicker taxonomy for large groups, you can use :meth:`PermutationGroup.is_alt_sym`. However, :meth:`PermutationGroup.is_alt_sym` may not be accurate and is not able to distinguish between an alternating group and a symmetric group. See Also ======== is_alt_sym""" [end of new definitions in sympy/combinatorics/perm_groups.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
scikit-learn__scikit-learn-15010	15,010	scikit-learn/scikit-learn	0.22	a91bae74aaca4979f5d927db327654b1d8e3ae58	2019-09-18T12:45:15Z	diff --git a/doc/whats_new/v0.22.rst b/doc/whats_new/v0.22.rst index 4ae47980a51da..8c90650c3a1f0 100644 --- a/doc/whats_new/v0.22.rst +++ b/doc/whats_new/v0.22.rst @@ -307,6 +307,10 @@ Changelog k-Nearest Neighbors. :issue:`12852` by :user:`Ashim Bhattarai <ashimb9>` and `Thomas Fan`_. +- \|Enhancement\| Adds parameter `add_indicator` to :class:`imputer.KNNImputer` + to get indicator of missing data. + :pr:`15010` by :user:`Guillaume Lemaitre <glemaitre>`. + - \|Feature\| :class:`impute.IterativeImputer` has new `skip_compute` flag that is False by default, which, when True, will skip computation on features that have no missing values during the fit phase. :issue:`13773` by diff --git a/sklearn/impute/_base.py b/sklearn/impute/_base.py index 3c0ce72cb2689..2ad49833641dc 100644 --- a/sklearn/impute/_base.py +++ b/sklearn/impute/_base.py @@ -2,10 +2,8 @@ # Sergey Feldman <sergeyfeldman@gmail.com> # License: BSD 3 clause -from __future__ import division - -import warnings import numbers +import warnings import numpy as np import numpy.ma as ma @@ -64,7 +62,60 @@ def _most_frequent(array, extra_value, n_repeat): return extra_value -class SimpleImputer(TransformerMixin, BaseEstimator): +class _BaseImputer(TransformerMixin, BaseEstimator): + """Base class for all imputers. + + It adds automatically support for `add_indicator`. + """ + + def __init__(self, missing_values=np.nan, add_indicator=False): + self.missing_values = missing_values + self.add_indicator = add_indicator + + def _fit_indicator(self, X): + """Fit a MissingIndicator.""" + if self.add_indicator: + self.indicator_ = MissingIndicator( + missing_values=self.missing_values, error_on_new=False + ) + self.indicator_.fit(X) + else: + self.indicator_ = None + + def _transform_indicator(self, X): + """Compute the indicator mask.' + + Note that X must be the original data as passed to the imputer before + any imputation, since imputation may be done inplace in some cases. + """ + if self.add_indicator: + if not hasattr(self, 'indicator_'): + raise ValueError( + "Make sure to call _fit_indicator before " + "_transform_indicator" + ) + return self.indicator_.transform(X) + + def _concatenate_indicator(self, X_imputed, X_indicator): + """Concatenate indicator mask with the imputed data.""" + if not self.add_indicator: + return X_imputed + + hstack = sparse.hstack if sparse.issparse(X_imputed) else np.hstack + if X_indicator is None: + raise ValueError( + "Data from the missing indicator are not provided. Call " + "_fit_indicator and _transform_indicator in the imputer " + "implementation." + ) + + return hstack((X_imputed, X_indicator)) + + def _more_tags(self): + return {'allow_nan': is_scalar_nan(self.missing_values)} + + +class SimpleImputer(_BaseImputer): """Imputation transformer for completing missing values. Read more in the :ref:`User Guide <impute>`. @@ -153,12 +204,14 @@ class SimpleImputer(TransformerMixin, BaseEstimator): """ def __init__(self, missing_values=np.nan, strategy="mean", fill_value=None, verbose=0, copy=True, add_indicator=False): - self.missing_values = missing_values + super().__init__( + missing_values=missing_values, + add_indicator=add_indicator + ) self.strategy = strategy self.fill_value = fill_value self.verbose = verbose self.copy = copy - self.add_indicator = add_indicator def _validate_input(self, X): allowed_strategies = ["mean", "median", "most_frequent", "constant"] @@ -213,6 +266,7 @@ def fit(self, X, y=None): self : SimpleImputer """ X = self._validate_input(X) + super()._fit_indicator(X) # default fill_value is 0 for numerical input and "missing_value" # otherwise @@ -249,14 +303,6 @@ def fit(self, X, y=None): self.strategy, self.missing_values, fill_value) - - if self.add_indicator: - self.indicator_ = MissingIndicator( - missing_values=self.missing_values, error_on_new=False) - self.indicator_.fit(X) - else: - self.indicator_ = None - return self def _sparse_fit(self, X, strategy, missing_values, fill_value): @@ -358,6 +404,7 @@ def transform(self, X): check_is_fitted(self) X = self._validate_input(X) + X_indicator = super()._transform_indicator(X) statistics = self.statistics_ @@ -365,9 +412,6 @@ def transform(self, X): raise ValueError("X has %d features per sample, expected %d" % (X.shape[1], self.statistics_.shape[0])) - if self.add_indicator: - X_trans_indicator = self.indicator_.transform(X) - # Delete the invalid columns if strategy is not constant if self.strategy == "constant": valid_statistics = statistics @@ -393,8 +437,9 @@ def transform(self, X): "array instead.") else: mask = _get_mask(X.data, self.missing_values) - indexes = np.repeat(np.arange(len(X.indptr) - 1, dtype=np.int), - np.diff(X.indptr))[mask] + indexes = np.repeat( + np.arange(len(X.indptr) - 1, dtype=np.int), + np.diff(X.indptr))[mask] X.data[mask] = valid_statistics[indexes].astype(X.dtype, copy=False) @@ -406,14 +451,7 @@ def transform(self, X): X[coordinates] = values - if self.add_indicator: - hstack = sparse.hstack if sparse.issparse(X) else np.hstack - X = hstack((X, X_trans_indicator)) - - return X - - def _more_tags(self): - return {'allow_nan': True} + return super()._concatenate_indicator(X, X_indicator) class MissingIndicator(TransformerMixin, BaseEstimator): diff --git a/sklearn/impute/_iterative.py b/sklearn/impute/_iterative.py index d797fca2c5e87..fb0045284cf87 100644 --- a/sklearn/impute/_iterative.py +++ b/sklearn/impute/_iterative.py @@ -8,7 +8,7 @@ from scipy import stats import numpy as np -from ..base import clone, BaseEstimator, TransformerMixin +from ..base import clone from ..exceptions import ConvergenceWarning from ..preprocessing import normalize from ..utils import check_array, check_random_state, _safe_indexing @@ -16,8 +16,9 @@ from ..utils import is_scalar_nan from ..utils._mask import _get_mask -from ._base import (MissingIndicator, SimpleImputer, - _check_inputs_dtype) +from ._base import _BaseImputer +from ._base import SimpleImputer +from ._base import _check_inputs_dtype _ImputerTriplet = namedtuple('_ImputerTriplet', ['feat_idx', @@ -25,7 +26,7 @@ 'estimator']) -class IterativeImputer(TransformerMixin, BaseEstimator): +class IterativeImputer(_BaseImputer): """Multivariate imputer that estimates each feature from all the others. A strategy for imputing missing values by modeling each feature with @@ -219,9 +220,12 @@ def __init__(self, verbose=0, random_state=None, add_indicator=False): + super().__init__( + missing_values=missing_values, + add_indicator=add_indicator + ) self.estimator = estimator - self.missing_values = missing_values self.sample_posterior = sample_posterior self.max_iter = max_iter self.tol = tol @@ -233,7 +237,6 @@ def __init__(self, self.max_value = max_value self.verbose = verbose self.random_state = random_state - self.add_indicator = add_indicator def _impute_one_feature(self, X_filled, @@ -302,7 +305,7 @@ def _impute_one_feature(self, # get posterior samples if there is at least one missing value X_test = _safe_indexing(X_filled[:, neighbor_feat_idx], - missing_row_mask) + missing_row_mask) if self.sample_posterior: mus, sigmas = estimator.predict(X_test, return_std=True) imputed_values = np.zeros(mus.shape, dtype=X_filled.dtype) @@ -505,8 +508,9 @@ def _initial_imputation(self, X): mask_missing_values = _get_mask(X, self.missing_values) if self.initial_imputer_ is None: self.initial_imputer_ = SimpleImputer( - missing_values=self.missing_values, - strategy=self.initial_strategy) + missing_values=self.missing_values, + strategy=self.initial_strategy + ) X_filled = self.initial_imputer_.fit_transform(X) else: X_filled = self.initial_imputer_.transform(X) @@ -532,7 +536,7 @@ def fit_transform(self, X, y=None): Returns ------- Xt : array-like, shape (n_samples, n_features) - The imputed input data. + The imputed input data. """ self.random_state_ = getattr(self, "random_state_", check_random_state(self.random_state)) @@ -548,37 +552,32 @@ def fit_transform(self, X, y=None): .format(self.tol) ) - if self.add_indicator: - self.indicator_ = MissingIndicator( - missing_values=self.missing_values, error_on_new=False) - X_trans_indicator = self.indicator_.fit_transform(X) - else: - self.indicator_ = None - if self.estimator is None: from ..linear_model import BayesianRidge self._estimator = BayesianRidge() else: self._estimator = clone(self.estimator) - self.imputation_sequence_ = [] - if hasattr(self._estimator, 'random_state'): self._estimator.random_state = self.random_state_ + self.imputation_sequence_ = [] + self._min_value = -np.inf if self.min_value is None else self.min_value self._max_value = np.inf if self.max_value is None else self.max_value self.initial_imputer_ = None + super()._fit_indicator(X) + X_indicator = super()._transform_indicator(X) X, Xt, mask_missing_values = self._initial_imputation(X) if self.max_iter == 0 or np.all(mask_missing_values): self.n_iter_ = 0 - return Xt + return super()._concatenate_indicator(Xt, X_indicator) # Edge case: a single feature. We return the initial ... if Xt.shape[1] == 1: self.n_iter_ = 0 - return Xt + return super()._concatenate_indicator(Xt, X_indicator) # order in which to impute # note this is probably too slow for large feature data (d > 100000) @@ -596,7 +595,9 @@ def fit_transform(self, X, y=None): start_t = time() if not self.sample_posterior: Xt_previous = Xt.copy() - normalized_tol = self.tol * np.max(np.abs(X[~mask_missing_values])) + normalized_tol = self.tol * np.max( + np.abs(X[~mask_missing_values]) + ) for self.n_iter_ in range(1, self.max_iter + 1): if self.imputation_order == 'random': ordered_idx = self._get_ordered_idx(mask_missing_values) @@ -624,7 +625,7 @@ def fit_transform(self, X, y=None): if self.verbose > 0: print('[IterativeImputer] ' 'Change: {}, scaled tolerance: {} '.format( - inf_norm, normalized_tol)) + inf_norm, normalized_tol)) if inf_norm < normalized_tol: if self.verbose > 0: print('[IterativeImputer] Early stopping criterion ' @@ -636,10 +637,7 @@ def fit_transform(self, X, y=None): warnings.warn("[IterativeImputer] Early stopping criterion not" " reached.", ConvergenceWarning) Xt[~mask_missing_values] = X[~mask_missing_values] - - if self.add_indicator: - Xt = np.hstack((Xt, X_trans_indicator)) - return Xt + return super()._concatenate_indicator(Xt, X_indicator) def transform(self, X): """Imputes all missing values in X. @@ -659,13 +657,11 @@ def transform(self, X): """ check_is_fitted(self) - if self.add_indicator: - X_trans_indicator = self.indicator_.transform(X) - + X_indicator = super()._transform_indicator(X) X, Xt, mask_missing_values = self._initial_imputation(X) if self.n_iter_ == 0 or np.all(mask_missing_values): - return Xt + return super()._concatenate_indicator(Xt, X_indicator) imputations_per_round = len(self.imputation_sequence_) // self.n_iter_ i_rnd = 0 @@ -691,9 +687,7 @@ def transform(self, X): Xt[~mask_missing_values] = X[~mask_missing_values] - if self.add_indicator: - Xt = np.hstack((Xt, X_trans_indicator)) - return Xt + return super()._concatenate_indicator(Xt, X_indicator) def fit(self, X, y=None): """Fits the imputer on X and return self. @@ -713,6 +707,3 @@ def fit(self, X, y=None): """ self.fit_transform(X) return self - - def _more_tags(self): - return {'allow_nan': True} diff --git a/sklearn/impute/_knn.py b/sklearn/impute/_knn.py index 15380ac18e3cf..bc8add0bf7a9b 100644 --- a/sklearn/impute/_knn.py +++ b/sklearn/impute/_knn.py @@ -1,6 +1,6 @@ import numpy as np -from ..base import BaseEstimator, TransformerMixin +from ._base import _BaseImputer from ..utils.validation import FLOAT_DTYPES from ..metrics import pairwise_distances from ..metrics.pairwise import _NAN_METRICS @@ -12,7 +12,7 @@ from ..utils.validation import check_is_fitted -class KNNImputer(TransformerMixin, BaseEstimator): +class KNNImputer(_BaseImputer): """Imputation for completing missing values using k-Nearest Neighbors. Each sample's missing values are imputed using the mean value from @@ -32,7 +32,7 @@ class KNNImputer(TransformerMixin, BaseEstimator): n_neighbors : int, default=5 Number of neighboring samples to use for imputation. - weights : str or callable, default='uniform' + weights : {'uniform', 'distance'} or callable, default='uniform' Weight function used in prediction. Possible values: - 'uniform' : uniform weights. All points in each neighborhood are @@ -44,7 +44,7 @@ class KNNImputer(TransformerMixin, BaseEstimator): array of distances, and returns an array of the same shape containing the weights. - metric : str or callable, default='nan_euclidean' + metric : {'nan_euclidean'} or callable, default='nan_euclidean' Distance metric for searching neighbors. Possible values: - 'nan_euclidean' @@ -53,10 +53,24 @@ class KNNImputer(TransformerMixin, BaseEstimator): accepts two arrays, X and Y, and a `missing_values` keyword in `kwds` and returns a scalar distance value. - copy : boolean, default=True + copy : bool, default=True If True, a copy of X will be created. If False, imputation will be done in-place whenever possible. + add_indicator : bool, default=False + If True, a :class:`MissingIndicator` transform will stack onto the + output of the imputer's transform. This allows a predictive estimator + to account for missingness despite imputation. If a feature has no + missing values at fit/train time, the feature won't appear on the + missing indicator even if there are missing values at transform/test + time. + + Attributes + ---------- + indicator_ : :class:`sklearn.impute.MissingIndicator` + Indicator used to add binary indicators for missing values. + ``None`` if add_indicator is False. + References ---------- * Olga Troyanskaya, Michael Cantor, Gavin Sherlock, Pat Brown, Trevor @@ -78,9 +92,12 @@ class KNNImputer(TransformerMixin, BaseEstimator): """ def __init__(self, missing_values=np.nan, n_neighbors=5, - weights="uniform", metric="nan_euclidean", copy=True): - - self.missing_values = missing_values + weights="uniform", metric="nan_euclidean", copy=True, + add_indicator=False): + super().__init__( + missing_values=missing_values, + add_indicator=add_indicator + ) self.n_neighbors = n_neighbors self.weights = weights self.metric = metric @@ -145,7 +162,6 @@ def fit(self, X, y=None): ------- self : object """ - # Check data integrity and calling arguments if not is_scalar_nan(self.missing_values): force_all_finite = True @@ -160,11 +176,11 @@ def fit(self, X, y=None): X = check_array(X, accept_sparse=False, dtype=FLOAT_DTYPES, force_all_finite=force_all_finite, copy=self.copy) + super()._fit_indicator(X) _check_weights(self.weights) self._fit_X = X self._mask_fit_X = _get_mask(self._fit_X, self.missing_values) - return self def transform(self, X): @@ -189,6 +205,7 @@ def transform(self, X): force_all_finite = "allow-nan" X = check_array(X, accept_sparse=False, dtype=FLOAT_DTYPES, force_all_finite=force_all_finite, copy=self.copy) + X_indicator = super()._transform_indicator(X) if X.shape[1] != self._fit_X.shape[1]: raise ValueError("Incompatible dimension between the fitted " @@ -237,7 +254,7 @@ def transform(self, X): # distances for samples that needed imputation for column dist_subset = (dist[dist_idx_map[receivers_idx]] - [:, potential_donors_idx]) + [:, potential_donors_idx]) # receivers with all nan distances impute with mean all_nan_dist_mask = np.isnan(dist_subset).all(axis=1) @@ -255,7 +272,7 @@ def transform(self, X): # receivers with at least one defined distance receivers_idx = receivers_idx[~all_nan_dist_mask] dist_subset = (dist[dist_idx_map[receivers_idx]] - [:, potential_donors_idx]) + [:, potential_donors_idx]) n_neighbors = min(self.n_neighbors, len(potential_donors_idx)) value = self._calc_impute(dist_subset, n_neighbors, @@ -263,7 +280,4 @@ def transform(self, X): mask_fit_X[potential_donors_idx, col]) X[receivers_idx, col] = value - return X[:, valid_idx] - - def _more_tags(self): - return {'allow_nan': is_scalar_nan(self.missing_values)} + return super()._concatenate_indicator(X[:, valid_idx], X_indicator)	diff --git a/sklearn/impute/tests/test_base.py b/sklearn/impute/tests/test_base.py new file mode 100644 index 0000000000000..37866943a727a --- /dev/null +++ b/sklearn/impute/tests/test_base.py @@ -0,0 +1,48 @@ +import pytest + +import numpy as np + +from sklearn.impute._base import _BaseImputer + + +@pytest.fixture +def data(): + X = np.random.randn(10, 2) + X[::2] = np.nan + return X + + +class NoFitIndicatorImputer(_BaseImputer): + def fit(self, X, y=None): + return self + + def transform(self, X, y=None): + return self._concatenate_indicator(X, self._transform_indicator(X)) + + +class NoTransformIndicatorImputer(_BaseImputer): + def fit(self, X, y=None): + super()._fit_indicator(X) + return self + + def transform(self, X, y=None): + return self._concatenate_indicator(X, None) + + +def test_base_imputer_not_fit(data): + imputer = NoFitIndicatorImputer(add_indicator=True) + err_msg = "Make sure to call _fit_indicator before _transform_indicator" + with pytest.raises(ValueError, match=err_msg): + imputer.fit(data).transform(data) + with pytest.raises(ValueError, match=err_msg): + imputer.fit_transform(data) + + +def test_base_imputer_not_transform(data): + imputer = NoTransformIndicatorImputer(add_indicator=True) + err_msg = ("Call _fit_indicator and _transform_indicator in the " + "imputer implementation") + with pytest.raises(ValueError, match=err_msg): + imputer.fit(data).transform(data) + with pytest.raises(ValueError, match=err_msg): + imputer.fit_transform(data) diff --git a/sklearn/impute/tests/test_common.py b/sklearn/impute/tests/test_common.py new file mode 100644 index 0000000000000..d4fc457bf6c28 --- /dev/null +++ b/sklearn/impute/tests/test_common.py @@ -0,0 +1,86 @@ +import pytest + +import numpy as np +from scipy import sparse + +from sklearn.utils.testing import assert_allclose +from sklearn.utils.testing import assert_allclose_dense_sparse +from sklearn.utils.testing import assert_array_equal + +from sklearn.experimental import enable_iterative_imputer # noqa + +from sklearn.impute import IterativeImputer +from sklearn.impute import KNNImputer +from sklearn.impute import SimpleImputer + + +IMPUTERS = [IterativeImputer(), KNNImputer(), SimpleImputer()] +SPARSE_IMPUTERS = [SimpleImputer()] + + +# ConvergenceWarning will be raised by the IterativeImputer +@pytest.mark.filterwarnings("ignore::sklearn.exceptions.ConvergenceWarning") +@pytest.mark.parametrize("imputer", IMPUTERS) +def test_imputation_missing_value_in_test_array(imputer): + # [Non Regression Test for issue #13968] Missing value in test set should + # not throw an error and return a finite dataset + train = [[1], [2]] + test = [[3], [np.nan]] + imputer.set_params(add_indicator=True) + imputer.fit(train).transform(test) + + +# ConvergenceWarning will be raised by the IterativeImputer +@pytest.mark.filterwarnings("ignore::sklearn.exceptions.ConvergenceWarning") +@pytest.mark.parametrize("marker", [np.nan, -1, 0]) +@pytest.mark.parametrize("imputer", IMPUTERS) +def test_imputers_add_indicator(marker, imputer): + X = np.array([ + [marker, 1, 5, marker, 1], + [2, marker, 1, marker, 2], + [6, 3, marker, marker, 3], + [1, 2, 9, marker, 4] + ]) + X_true_indicator = np.array([ + [1., 0., 0., 1.], + [0., 1., 0., 1.], + [0., 0., 1., 1.], + [0., 0., 0., 1.] + ]) + imputer.set_params(missing_values=marker, add_indicator=True) + + X_trans = imputer.fit_transform(X) + assert_allclose(X_trans[:, -4:], X_true_indicator) + assert_array_equal(imputer.indicator_.features_, np.array([0, 1, 2, 3])) + + imputer.set_params(add_indicator=False) + X_trans_no_indicator = imputer.fit_transform(X) + assert_allclose(X_trans[:, :-4], X_trans_no_indicator) + + +# ConvergenceWarning will be raised by the IterativeImputer +@pytest.mark.filterwarnings("ignore::sklearn.exceptions.ConvergenceWarning") +@pytest.mark.parametrize("marker", [np.nan, -1]) +@pytest.mark.parametrize("imputer", SPARSE_IMPUTERS) +def test_imputers_add_indicator_sparse(imputer, marker): + X = sparse.csr_matrix([ + [marker, 1, 5, marker, 1], + [2, marker, 1, marker, 2], + [6, 3, marker, marker, 3], + [1, 2, 9, marker, 4] + ]) + X_true_indicator = sparse.csr_matrix([ + [1., 0., 0., 1.], + [0., 1., 0., 1.], + [0., 0., 1., 1.], + [0., 0., 0., 1.] + ]) + imputer.set_params(missing_values=marker, add_indicator=True) + + X_trans = imputer.fit_transform(X) + assert_allclose_dense_sparse(X_trans[:, -4:], X_true_indicator) + assert_array_equal(imputer.indicator_.features_, np.array([0, 1, 2, 3])) + + imputer.set_params(add_indicator=False) + X_trans_no_indicator = imputer.fit_transform(X) + assert_allclose_dense_sparse(X_trans[:, :-4], X_trans_no_indicator) diff --git a/sklearn/impute/tests/test_impute.py b/sklearn/impute/tests/test_impute.py index c3c8b4cc329cb..6ba49c2dc9e50 100644 --- a/sklearn/impute/tests/test_impute.py +++ b/sklearn/impute/tests/test_impute.py @@ -462,16 +462,6 @@ def test_imputation_constant_pandas(dtype): assert_array_equal(X_trans, X_true) -@pytest.mark.parametrize('Imputer', (SimpleImputer, IterativeImputer)) -def test_imputation_missing_value_in_test_array(Imputer): - # [Non Regression Test for issue #13968] Missing value in test set should - # not throw an error and return a finite dataset - train = [[1], [2]] - test = [[3], [np.nan]] - imputer = Imputer(add_indicator=True) - imputer.fit(train).transform(test) - - @pytest.mark.parametrize("X", [[[1], [2]], [[1], [np.nan]]]) def test_iterative_imputer_one_feature(X): # check we exit early when there is a single feature @@ -1243,32 +1233,6 @@ def test_missing_indicator_sparse_no_explicit_zeros(): assert Xt.getnnz() == Xt.sum() -@pytest.mark.parametrize("marker", [np.nan, -1, 0]) -@pytest.mark.parametrize("imputer_constructor", - [SimpleImputer, IterativeImputer]) -def test_imputers_add_indicator(marker, imputer_constructor): - X = np.array([ - [marker, 1, 5, marker, 1], - [2, marker, 1, marker, 2], - [6, 3, marker, marker, 3], - [1, 2, 9, marker, 4] - ]) - X_true_indicator = np.array([ - [1., 0., 0., 1.], - [0., 1., 0., 1.], - [0., 0., 1., 1.], - [0., 0., 0., 1.] - ]) - imputer = imputer_constructor(missing_values=marker, - add_indicator=True) - - X_trans = imputer.fit(X).transform(X) - # The test is for testing the indicator, - # that's why we're looking at the last 4 columns only. - assert_allclose(X_trans[:, -4:], X_true_indicator) - assert_array_equal(imputer.indicator_.features_, np.array([0, 1, 2, 3])) - - @pytest.mark.parametrize("imputer_constructor", [SimpleImputer, IterativeImputer]) def test_imputer_without_indicator(imputer_constructor):	diff --git a/doc/whats_new/v0.22.rst b/doc/whats_new/v0.22.rst index 4ae47980a51da..8c90650c3a1f0 100644 --- a/doc/whats_new/v0.22.rst +++ b/doc/whats_new/v0.22.rst @@ -307,6 +307,10 @@ Changelog k-Nearest Neighbors. :issue:`12852` by :user:`Ashim Bhattarai <ashimb9>` and `Thomas Fan`_. +- \|Enhancement\| Adds parameter `add_indicator` to :class:`imputer.KNNImputer` + to get indicator of missing data. + :pr:`15010` by :user:`Guillaume Lemaitre <glemaitre>`. + - \|Feature\| :class:`impute.IterativeImputer` has new `skip_compute` flag that is False by default, which, when True, will skip computation on features that have no missing values during the fit phase. :issue:`13773` by	[ { "components": [ { "doc": "Base class for all imputers.\n\nIt adds automatically support for `add_indicator`.", "lines": [ 65, 115 ], "name": "_BaseImputer", "signature": "class _BaseImputer(TransformerMixin, BaseEstimator):", "type": "c...	[ "sklearn/impute/tests/test_base.py::test_base_imputer_not_fit", "sklearn/impute/tests/test_base.py::test_base_imputer_not_transform", "sklearn/impute/tests/test_common.py::test_imputation_missing_value_in_test_array[imputer0]", "sklearn/impute/tests/test_common.py::test_imputation_missing_value_in_test_array[...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG] ENH add missing indicator in KNNImputer Add the `add_indicator` to KNNImputer for consistency with other imputers. Since all imputers would share this feature, we can create a private base class. TODO: - [x] add the missing indicator to `KNNImputer` - [x] potentially create a base class for all future imputer - [x] add either common test / test for KNNImputer For another PR - [ ] update the example to use the feature + notebook style ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/impute/_base.py] (definition of _BaseImputer:) class _BaseImputer(TransformerMixin, BaseEstimator): """Base class for all imputers. It adds automatically support for `add_indicator`.""" (definition of _BaseImputer.__init__:) def __init__(self, missing_values=np.nan, add_indicator=False): (definition of _BaseImputer._fit_indicator:) def _fit_indicator(self, X): """Fit a MissingIndicator.""" (definition of _BaseImputer._transform_indicator:) def _transform_indicator(self, X): """Compute the indicator mask.' Note that X must be the original data as passed to the imputer before any imputation, since imputation may be done inplace in some cases.""" (definition of _BaseImputer._concatenate_indicator:) def _concatenate_indicator(self, X_imputed, X_indicator): """Concatenate indicator mask with the imputed data.""" (definition of _BaseImputer._more_tags:) def _more_tags(self): [end of new definitions in sklearn/impute/_base.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c96e0958da46ebef482a4084cdda3285d5f5ad23
scikit-learn__scikit-learn-15007	15,007	scikit-learn/scikit-learn	0.24	91a0e4041e6a7ec3752b394956473503e87a5924	2019-09-18T06:03:48Z	diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 35fa24ac9a846..b7b1c490777bd 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -900,7 +900,7 @@ Miscellaneous manifold.smacof manifold.spectral_embedding manifold.trustworthiness - + .. _metrics_ref: @@ -981,6 +981,7 @@ details. metrics.mean_squared_error metrics.mean_squared_log_error metrics.median_absolute_error + metrics.mean_absolute_percentage_error metrics.r2_score metrics.mean_poisson_deviance metrics.mean_gamma_deviance diff --git a/doc/modules/model_evaluation.rst b/doc/modules/model_evaluation.rst index cdbbc0814c8b1..bb8b59889a3f5 100644 --- a/doc/modules/model_evaluation.rst +++ b/doc/modules/model_evaluation.rst @@ -54,51 +54,52 @@ the model and the data, like :func:`metrics.mean_squared_error`, are available as neg_mean_squared_error which return the negated value of the metric. -============================== ============================================= ================================== -Scoring Function Comment -============================== ============================================= ================================== +==================================== ============================================== ================================== +Scoring Function Comment +==================================== ============================================== ================================== Classification -'accuracy' :func:`metrics.accuracy_score` -'balanced_accuracy' :func:`metrics.balanced_accuracy_score` -'average_precision' :func:`metrics.average_precision_score` -'neg_brier_score' :func:`metrics.brier_score_loss` -'f1' :func:`metrics.f1_score` for binary targets -'f1_micro' :func:`metrics.f1_score` micro-averaged -'f1_macro' :func:`metrics.f1_score` macro-averaged -'f1_weighted' :func:`metrics.f1_score` weighted average -'f1_samples' :func:`metrics.f1_score` by multilabel sample -'neg_log_loss' :func:`metrics.log_loss` requires ``predict_proba`` support -'precision' etc. :func:`metrics.precision_score` suffixes apply as with 'f1' -'recall' etc. :func:`metrics.recall_score` suffixes apply as with 'f1' -'jaccard' etc. :func:`metrics.jaccard_score` suffixes apply as with 'f1' -'roc_auc' :func:`metrics.roc_auc_score` -'roc_auc_ovr' :func:`metrics.roc_auc_score` -'roc_auc_ovo' :func:`metrics.roc_auc_score` -'roc_auc_ovr_weighted' :func:`metrics.roc_auc_score` -'roc_auc_ovo_weighted' :func:`metrics.roc_auc_score` +'accuracy' :func:`metrics.accuracy_score` +'balanced_accuracy' :func:`metrics.balanced_accuracy_score` +'average_precision' :func:`metrics.average_precision_score` +'neg_brier_score' :func:`metrics.brier_score_loss` +'f1' :func:`metrics.f1_score` for binary targets +'f1_micro' :func:`metrics.f1_score` micro-averaged +'f1_macro' :func:`metrics.f1_score` macro-averaged +'f1_weighted' :func:`metrics.f1_score` weighted average +'f1_samples' :func:`metrics.f1_score` by multilabel sample +'neg_log_loss' :func:`metrics.log_loss` requires ``predict_proba`` support +'precision' etc. :func:`metrics.precision_score` suffixes apply as with 'f1' +'recall' etc. :func:`metrics.recall_score` suffixes apply as with 'f1' +'jaccard' etc. :func:`metrics.jaccard_score` suffixes apply as with 'f1' +'roc_auc' :func:`metrics.roc_auc_score` +'roc_auc_ovr' :func:`metrics.roc_auc_score` +'roc_auc_ovo' :func:`metrics.roc_auc_score` +'roc_auc_ovr_weighted' :func:`metrics.roc_auc_score` +'roc_auc_ovo_weighted' :func:`metrics.roc_auc_score` Clustering -'adjusted_mutual_info_score' :func:`metrics.adjusted_mutual_info_score` -'adjusted_rand_score' :func:`metrics.adjusted_rand_score` -'completeness_score' :func:`metrics.completeness_score` -'fowlkes_mallows_score' :func:`metrics.fowlkes_mallows_score` -'homogeneity_score' :func:`metrics.homogeneity_score` -'mutual_info_score' :func:`metrics.mutual_info_score` -'normalized_mutual_info_score' :func:`metrics.normalized_mutual_info_score` -'v_measure_score' :func:`metrics.v_measure_score` +'adjusted_mutual_info_score' :func:`metrics.adjusted_mutual_info_score` +'adjusted_rand_score' :func:`metrics.adjusted_rand_score` +'completeness_score' :func:`metrics.completeness_score` +'fowlkes_mallows_score' :func:`metrics.fowlkes_mallows_score` +'homogeneity_score' :func:`metrics.homogeneity_score` +'mutual_info_score' :func:`metrics.mutual_info_score` +'normalized_mutual_info_score' :func:`metrics.normalized_mutual_info_score` +'v_measure_score' :func:`metrics.v_measure_score` Regression -'explained_variance' :func:`metrics.explained_variance_score` -'max_error' :func:`metrics.max_error` -'neg_mean_absolute_error' :func:`metrics.mean_absolute_error` -'neg_mean_squared_error' :func:`metrics.mean_squared_error` -'neg_root_mean_squared_error' :func:`metrics.mean_squared_error` -'neg_mean_squared_log_error' :func:`metrics.mean_squared_log_error` -'neg_median_absolute_error' :func:`metrics.median_absolute_error` -'r2' :func:`metrics.r2_score` -'neg_mean_poisson_deviance' :func:`metrics.mean_poisson_deviance` -'neg_mean_gamma_deviance' :func:`metrics.mean_gamma_deviance` -============================== ============================================= ================================== +'explained_variance' :func:`metrics.explained_variance_score` +'max_error' :func:`metrics.max_error` +'neg_mean_absolute_error' :func:`metrics.mean_absolute_error` +'neg_mean_squared_error' :func:`metrics.mean_squared_error` +'neg_root_mean_squared_error' :func:`metrics.mean_squared_error` +'neg_mean_squared_log_error' :func:`metrics.mean_squared_log_error` +'neg_median_absolute_error' :func:`metrics.median_absolute_error` +'r2' :func:`metrics.r2_score` +'neg_mean_poisson_deviance' :func:`metrics.mean_poisson_deviance` +'neg_mean_gamma_deviance' :func:`metrics.mean_gamma_deviance` +'neg_mean_absolute_percentage_error' :func:`metrics.mean_absolute_percentage_error` +==================================== ============================================== ================================== Usage examples: @@ -1963,6 +1964,42 @@ function:: >>> mean_squared_log_error(y_true, y_pred) 0.044... +.. _mean_absolute_percentage_error: + +Mean absolute percentage error +------------------------------ +The :func:`mean_absolute_percentage_error` (MAPE), also known as mean absolute +percentage deviation (MAPD), is an evaluation metric for regression problems. +The idea of this metric is to be sensitive to relative errors. It is for example +not changed by a global scaling of the target variable. + +If :math:`\hat{y}_i` is the predicted value of the :math:`i`-th sample +and :math:`y_i` is the corresponding true value, then the mean absolute percentage +error (MAPE) estimated over :math:`n_{\text{samples}}` is defined as + +.. math:: + + \text{MAPE}(y, \hat{y}) = \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}}-1} \frac{{}\left\| y_i - \hat{y}_i \right\|}{max(\epsilon, \left\| y_i \right\|)} + +where :math:`\epsilon` is an arbitrary small yet strictly positive number to +avoid undefined results when y is zero. + +The :func:`mean_absolute_percentage_error` function supports multioutput. + +Here is a small example of usage of the :func:`mean_absolute_percentage_error` +function:: + + >>> from sklearn.metrics import mean_absolute_percentage_error + >>> y_true = [1, 10, 1e6] + >>> y_pred = [0.9, 15, 1.2e6] + >>> mean_absolute_percentage_error(y_true, y_pred) + 0.2666... + +In above example, if we had used `mean_absolute_error`, it would have ignored +the small magnitude values and only reflected the error in prediction of highest +magnitude value. But that problem is resolved in case of MAPE because it calculates +relative percentage error with respect to actual output. + .. _median_absolute_error: Median absolute error diff --git a/doc/whats_new/_contributors.rst b/doc/whats_new/_contributors.rst index cc3957eca1592..ca0f8ede93afa 100644 --- a/doc/whats_new/_contributors.rst +++ b/doc/whats_new/_contributors.rst @@ -176,4 +176,4 @@ .. _Nicolas Hug: https://github.com/NicolasHug -.. _Guillaume Lemaitre: https://github.com/glemaitre +.. _Guillaume Lemaitre: https://github.com/glemaitre \ No newline at end of file diff --git a/doc/whats_new/v0.24.rst b/doc/whats_new/v0.24.rst index c41f761de1018..e637e367d401e 100644 --- a/doc/whats_new/v0.24.rst +++ b/doc/whats_new/v0.24.rst @@ -150,6 +150,12 @@ Changelog :mod:`sklearn.metrics` ...................... +- \|Feature\| Added :func:`metrics.mean_absolute_percentage_error` metric and + the associated scorer for regression problems. :issue:`10708` fixed with the + PR :pr:`15007` by :user:`Ashutosh Hathidara <ashutosh1919>`. The scorer and + some practical test cases were taken from PR :pr:`10711` by + :user:`Mohamed Ali Jamaoui <mohamed-ali>`. + - \|Fix\| Fixed a bug in :func:`metrics.mean_squared_error` where the average of multiple RMSE values was incorrectly calculated as the root of the average of multiple MSE values. diff --git a/sklearn/metrics/__init__.py b/sklearn/metrics/__init__.py index 8bcb047ec8161..be28005631963 100644 --- a/sklearn/metrics/__init__.py +++ b/sklearn/metrics/__init__.py @@ -64,6 +64,7 @@ from ._regression import mean_squared_error from ._regression import mean_squared_log_error from ._regression import median_absolute_error +from ._regression import mean_absolute_percentage_error from ._regression import r2_score from ._regression import mean_tweedie_deviance from ._regression import mean_poisson_deviance @@ -128,6 +129,7 @@ 'mean_gamma_deviance', 'mean_tweedie_deviance', 'median_absolute_error', + 'mean_absolute_percentage_error', 'multilabel_confusion_matrix', 'mutual_info_score', 'ndcg_score', diff --git a/sklearn/metrics/_regression.py b/sklearn/metrics/_regression.py index 9064c018a24a9..ff3907d3c27ae 100644 --- a/sklearn/metrics/_regression.py +++ b/sklearn/metrics/_regression.py @@ -20,6 +20,7 @@ # Michael Eickenberg <michael.eickenberg@gmail.com> # Konstantin Shmelkov <konstantin.shmelkov@polytechnique.edu> # Christian Lorentzen <lorentzen.ch@googlemail.com> +# Ashutosh Hathidara <ashutoshhathidara98@gmail.com> # License: BSD 3 clause import numpy as np @@ -41,6 +42,7 @@ "mean_squared_error", "mean_squared_log_error", "median_absolute_error", + "mean_absolute_percentage_error", "r2_score", "explained_variance_score", "mean_tweedie_deviance", @@ -192,6 +194,81 @@ def mean_absolute_error(y_true, y_pred, , return np.average(output_errors, weights=multioutput) +def mean_absolute_percentage_error(y_true, y_pred, + sample_weight=None, + multioutput='uniform_average'): + """Mean absolute percentage error regression loss + + Note here that we do not represent the output as a percentage in range + [0, 100]. Instead, we represent it in range [0, 1/eps]. Read more in the + :ref:`User Guide <mean_absolute_percentage_error>`. + + Parameters + ---------- + y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) + Ground truth (correct) target values. + + y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) + Estimated target values. + + sample_weight : array-like of shape (n_samples,), default=None + Sample weights. + + multioutput : {'raw_values', 'uniform_average'} or array-like + Defines aggregating of multiple output values. + Array-like value defines weights used to average errors. + If input is list then the shape must be (n_outputs,). + + 'raw_values' : + Returns a full set of errors in case of multioutput input. + + 'uniform_average' : + Errors of all outputs are averaged with uniform weight. + + Returns + ------- + loss : float or ndarray of floats in the range [0, 1/eps] + If multioutput is 'raw_values', then mean absolute percentage error + is returned for each output separately. + If multioutput is 'uniform_average' or an ndarray of weights, then the + weighted average of all output errors is returned. + + MAPE output is non-negative floating point. The best value is 0.0. + But note the fact that bad predictions can lead to arbitarily large + MAPE values, especially if some y_true values are very close to zero. + Note that we return a large value instead of `inf` when y_true is zero. + + Examples + -------- + >>> from sklearn.metrics import mean_absolute_percentage_error + >>> y_true = [3, -0.5, 2, 7] + >>> y_pred = [2.5, 0.0, 2, 8] + >>> mean_absolute_percentage_error(y_true, y_pred) + 0.3273... + >>> y_true = [[0.5, 1], [-1, 1], [7, -6]] + >>> y_pred = [[0, 2], [-1, 2], [8, -5]] + >>> mean_absolute_percentage_error(y_true, y_pred) + 0.5515... + >>> mean_absolute_percentage_error(y_true, y_pred, multioutput=[0.3, 0.7]) + 0.6198... + """ + y_type, y_true, y_pred, multioutput = _check_reg_targets( + y_true, y_pred, multioutput) + check_consistent_length(y_true, y_pred, sample_weight) + epsilon = np.finfo(np.float64).eps + mape = np.abs(y_pred - y_true) / np.maximum(np.abs(y_true), epsilon) + output_errors = np.average(mape, + weights=sample_weight, axis=0) + if isinstance(multioutput, str): + if multioutput == 'raw_values': + return output_errors + elif multioutput == 'uniform_average': + # pass None as weights to np.average: uniform mean + multioutput = None + + return np.average(output_errors, weights=multioutput) + + @_deprecate_positional_args def mean_squared_error(y_true, y_pred, , sample_weight=None, diff --git a/sklearn/metrics/_scorer.py b/sklearn/metrics/_scorer.py index 1f05462928916..6098eae2d68a0 100644 --- a/sklearn/metrics/_scorer.py +++ b/sklearn/metrics/_scorer.py @@ -30,7 +30,7 @@ f1_score, roc_auc_score, average_precision_score, precision_score, recall_score, log_loss, balanced_accuracy_score, explained_variance_score, - brier_score_loss, jaccard_score) + brier_score_loss, jaccard_score, mean_absolute_percentage_error) from .cluster import adjusted_rand_score from .cluster import homogeneity_score @@ -614,6 +614,9 @@ def make_scorer(score_func, , greater_is_better=True, needs_proba=False, greater_is_better=False) neg_mean_absolute_error_scorer = make_scorer(mean_absolute_error, greater_is_better=False) +neg_mean_absolute_percentage_error_scorer = make_scorer( + mean_absolute_percentage_error, greater_is_better=False +) neg_median_absolute_error_scorer = make_scorer(median_absolute_error, greater_is_better=False) neg_root_mean_squared_error_scorer = make_scorer(mean_squared_error, @@ -674,6 +677,7 @@ def make_scorer(score_func, , greater_is_better=True, needs_proba=False, max_error=max_error_scorer, neg_median_absolute_error=neg_median_absolute_error_scorer, neg_mean_absolute_error=neg_mean_absolute_error_scorer, + neg_mean_absolute_percentage_error=neg_mean_absolute_percentage_error_scorer, # noqa neg_mean_squared_error=neg_mean_squared_error_scorer, neg_mean_squared_log_error=neg_mean_squared_log_error_scorer, neg_root_mean_squared_error=neg_root_mean_squared_error_scorer,	diff --git a/sklearn/metrics/tests/test_common.py b/sklearn/metrics/tests/test_common.py index 7301d21a35f39..3f2ba83b474c7 100644 --- a/sklearn/metrics/tests/test_common.py +++ b/sklearn/metrics/tests/test_common.py @@ -41,6 +41,7 @@ from sklearn.metrics import max_error from sklearn.metrics import matthews_corrcoef from sklearn.metrics import mean_absolute_error +from sklearn.metrics import mean_absolute_percentage_error from sklearn.metrics import mean_squared_error from sklearn.metrics import mean_tweedie_deviance from sklearn.metrics import mean_poisson_deviance @@ -98,6 +99,7 @@ "mean_absolute_error": mean_absolute_error, "mean_squared_error": mean_squared_error, "median_absolute_error": median_absolute_error, + "mean_absolute_percentage_error": mean_absolute_percentage_error, "explained_variance_score": explained_variance_score, "r2_score": partial(r2_score, multioutput='variance_weighted'), "mean_normal_deviance": partial(mean_tweedie_deviance, power=0), @@ -425,7 +427,7 @@ def precision_recall_curve_padded_thresholds(args, kwargs): # Regression metrics with "multioutput-continuous" format support MULTIOUTPUT_METRICS = { "mean_absolute_error", "median_absolute_error", "mean_squared_error", - "r2_score", "explained_variance_score" + "r2_score", "explained_variance_score", "mean_absolute_percentage_error" } # Symmetric with respect to their input arguments y_true and y_pred @@ -472,7 +474,7 @@ def precision_recall_curve_padded_thresholds(args, *kwargs): "macro_f0.5_score", "macro_f2_score", "macro_precision_score", "macro_recall_score", "log_loss", "hinge_loss", "mean_gamma_deviance", "mean_poisson_deviance", - "mean_compound_poisson_deviance" + "mean_compound_poisson_deviance", "mean_absolute_percentage_error" } @@ -1371,7 +1373,15 @@ def test_thresholded_multilabel_multioutput_permutations_invariance(name): y_true_perm = y_true[:, perm] current_score = metric(y_true_perm, y_score_perm) - assert_almost_equal(score, current_score) + if metric == mean_absolute_percentage_error: + assert np.isfinite(current_score) + assert current_score > 1e6 + # Here we are not comparing the values in case of MAPE because + # whenever y_true value is exactly zero, the MAPE value doesn't + # signify anything. Thus, in this case we are just expecting + # very large finite value. + else: + assert_almost_equal(score, current_score) @pytest.mark.parametrize( diff --git a/sklearn/metrics/tests/test_regression.py b/sklearn/metrics/tests/test_regression.py index c5e9743539612..5b8406cf7a61f 100644 --- a/sklearn/metrics/tests/test_regression.py +++ b/sklearn/metrics/tests/test_regression.py @@ -13,6 +13,7 @@ from sklearn.metrics import mean_squared_error from sklearn.metrics import mean_squared_log_error from sklearn.metrics import median_absolute_error +from sklearn.metrics import mean_absolute_percentage_error from sklearn.metrics import max_error from sklearn.metrics import r2_score from sklearn.metrics import mean_tweedie_deviance @@ -32,6 +33,9 @@ def test_regression_metrics(n_samples=50): np.log(1 + y_pred))) assert_almost_equal(mean_absolute_error(y_true, y_pred), 1.) assert_almost_equal(median_absolute_error(y_true, y_pred), 1.) + mape = mean_absolute_percentage_error(y_true, y_pred) + assert np.isfinite(mape) + assert mape > 1e6 assert_almost_equal(max_error(y_true, y_pred), 1.) assert_almost_equal(r2_score(y_true, y_pred), 0.995, 2) assert_almost_equal(explained_variance_score(y_true, y_pred), 1.) @@ -86,6 +90,10 @@ def test_multioutput_regression(): error = mean_absolute_error(y_true, y_pred) assert_almost_equal(error, (1. + 2. / 3) / 4.) + error = np.around(mean_absolute_percentage_error(y_true, y_pred), + decimals=2) + assert np.isfinite(error) + assert error > 1e6 error = median_absolute_error(y_true, y_pred) assert_almost_equal(error, (1. + 1.) / 4.) @@ -100,6 +108,7 @@ def test_regression_metrics_at_limits(): assert_almost_equal(mean_squared_error([0.], [0.], squared=False), 0.00, 2) assert_almost_equal(mean_squared_log_error([0.], [0.]), 0.00, 2) assert_almost_equal(mean_absolute_error([0.], [0.]), 0.00, 2) + assert_almost_equal(mean_absolute_percentage_error([0.], [0.]), 0.00, 2) assert_almost_equal(median_absolute_error([0.], [0.]), 0.00, 2) assert_almost_equal(max_error([0.], [0.]), 0.00, 2) assert_almost_equal(explained_variance_score([0.], [0.]), 1.00, 2) @@ -198,11 +207,14 @@ def test_regression_multioutput_array(): mse = mean_squared_error(y_true, y_pred, multioutput='raw_values') mae = mean_absolute_error(y_true, y_pred, multioutput='raw_values') + mape = mean_absolute_percentage_error(y_true, y_pred, + multioutput='raw_values') r = r2_score(y_true, y_pred, multioutput='raw_values') evs = explained_variance_score(y_true, y_pred, multioutput='raw_values') assert_array_almost_equal(mse, [0.125, 0.5625], decimal=2) assert_array_almost_equal(mae, [0.25, 0.625], decimal=2) + assert_array_almost_equal(mape, [0.0778, 0.2262], decimal=2) assert_array_almost_equal(r, [0.95, 0.93], decimal=2) assert_array_almost_equal(evs, [0.95, 0.93], decimal=2) @@ -254,12 +266,15 @@ def test_regression_custom_weights(): rmsew = mean_squared_error(y_true, y_pred, multioutput=[0.4, 0.6], squared=False) maew = mean_absolute_error(y_true, y_pred, multioutput=[0.4, 0.6]) + mapew = mean_absolute_percentage_error(y_true, y_pred, + multioutput=[0.4, 0.6]) rw = r2_score(y_true, y_pred, multioutput=[0.4, 0.6]) evsw = explained_variance_score(y_true, y_pred, multioutput=[0.4, 0.6]) assert_almost_equal(msew, 0.39, decimal=2) assert_almost_equal(rmsew, 0.59, decimal=2) assert_almost_equal(maew, 0.475, decimal=3) + assert_almost_equal(mapew, 0.1668, decimal=2) assert_almost_equal(rw, 0.94, decimal=2) assert_almost_equal(evsw, 0.94, decimal=2) @@ -308,3 +323,10 @@ def test_tweedie_deviance_continuity(): assert_allclose(mean_tweedie_deviance(y_true, y_pred, power=2 + 1e-10), mean_tweedie_deviance(y_true, y_pred, power=2), atol=1e-6) + + +def test_mean_absolute_percentage_error(): + random_number_generator = np.random.RandomState(42) + y_true = random_number_generator.exponential(size=100) + y_pred = 1.2 y_true + assert mean_absolute_percentage_error(y_true, y_pred) == pytest.approx(0.2) diff --git a/sklearn/metrics/tests/test_score_objects.py b/sklearn/metrics/tests/test_score_objects.py index f49197a706e70..227fd8bbadee9 100644 --- a/sklearn/metrics/tests/test_score_objects.py +++ b/sklearn/metrics/tests/test_score_objects.py @@ -43,10 +43,12 @@ REGRESSION_SCORERS = ['explained_variance', 'r2', 'neg_mean_absolute_error', 'neg_mean_squared_error', + 'neg_mean_absolute_percentage_error', 'neg_mean_squared_log_error', 'neg_median_absolute_error', 'neg_root_mean_squared_error', 'mean_absolute_error', + 'mean_absolute_percentage_error', 'mean_squared_error', 'median_absolute_error', 'max_error', 'neg_mean_poisson_deviance', 'neg_mean_gamma_deviance']	diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 35fa24ac9a846..b7b1c490777bd 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -900,7 +900,7 @@ Miscellaneous manifold.smacof manifold.spectral_embedding manifold.trustworthiness - + .. _metrics_ref: @@ -981,6 +981,7 @@ details. metrics.mean_squared_error metrics.mean_squared_log_error metrics.median_absolute_error + metrics.mean_absolute_percentage_error metrics.r2_score metrics.mean_poisson_deviance metrics.mean_gamma_deviance diff --git a/doc/modules/model_evaluation.rst b/doc/modules/model_evaluation.rst index cdbbc0814c8b1..bb8b59889a3f5 100644 --- a/doc/modules/model_evaluation.rst +++ b/doc/modules/model_evaluation.rst @@ -54,51 +54,52 @@ the model and the data, like :func:`metrics.mean_squared_error`, are available as neg_mean_squared_error which return the negated value of the metric. -============================== ============================================= ================================== -Scoring Function Comment -============================== ============================================= ================================== +==================================== ============================================== ================================== +Scoring Function Comment +==================================== ============================================== ================================== Classification -'accuracy' :func:`metrics.accuracy_score` -'balanced_accuracy' :func:`metrics.balanced_accuracy_score` -'average_precision' :func:`metrics.average_precision_score` -'neg_brier_score' :func:`metrics.brier_score_loss` -'f1' :func:`metrics.f1_score` for binary targets -'f1_micro' :func:`metrics.f1_score` micro-averaged -'f1_macro' :func:`metrics.f1_score` macro-averaged -'f1_weighted' :func:`metrics.f1_score` weighted average -'f1_samples' :func:`metrics.f1_score` by multilabel sample -'neg_log_loss' :func:`metrics.log_loss` requires ``predict_proba`` support -'precision' etc. :func:`metrics.precision_score` suffixes apply as with 'f1' -'recall' etc. :func:`metrics.recall_score` suffixes apply as with 'f1' -'jaccard' etc. :func:`metrics.jaccard_score` suffixes apply as with 'f1' -'roc_auc' :func:`metrics.roc_auc_score` -'roc_auc_ovr' :func:`metrics.roc_auc_score` -'roc_auc_ovo' :func:`metrics.roc_auc_score` -'roc_auc_ovr_weighted' :func:`metrics.roc_auc_score` -'roc_auc_ovo_weighted' :func:`metrics.roc_auc_score` +'accuracy' :func:`metrics.accuracy_score` +'balanced_accuracy' :func:`metrics.balanced_accuracy_score` +'average_precision' :func:`metrics.average_precision_score` +'neg_brier_score' :func:`metrics.brier_score_loss` +'f1' :func:`metrics.f1_score` for binary targets +'f1_micro' :func:`metrics.f1_score` micro-averaged +'f1_macro' :func:`metrics.f1_score` macro-averaged +'f1_weighted' :func:`metrics.f1_score` weighted average +'f1_samples' :func:`metrics.f1_score` by multilabel sample +'neg_log_loss' :func:`metrics.log_loss` requires ``predict_proba`` support +'precision' etc. :func:`metrics.precision_score` suffixes apply as with 'f1' +'recall' etc. :func:`metrics.recall_score` suffixes apply as with 'f1' +'jaccard' etc. :func:`metrics.jaccard_score` suffixes apply as with 'f1' +'roc_auc' :func:`metrics.roc_auc_score` +'roc_auc_ovr' :func:`metrics.roc_auc_score` +'roc_auc_ovo' :func:`metrics.roc_auc_score` +'roc_auc_ovr_weighted' :func:`metrics.roc_auc_score` +'roc_auc_ovo_weighted' :func:`metrics.roc_auc_score` Clustering -'adjusted_mutual_info_score' :func:`metrics.adjusted_mutual_info_score` -'adjusted_rand_score' :func:`metrics.adjusted_rand_score` -'completeness_score' :func:`metrics.completeness_score` -'fowlkes_mallows_score' :func:`metrics.fowlkes_mallows_score` -'homogeneity_score' :func:`metrics.homogeneity_score` -'mutual_info_score' :func:`metrics.mutual_info_score` -'normalized_mutual_info_score' :func:`metrics.normalized_mutual_info_score` -'v_measure_score' :func:`metrics.v_measure_score` +'adjusted_mutual_info_score' :func:`metrics.adjusted_mutual_info_score` +'adjusted_rand_score' :func:`metrics.adjusted_rand_score` +'completeness_score' :func:`metrics.completeness_score` +'fowlkes_mallows_score' :func:`metrics.fowlkes_mallows_score` +'homogeneity_score' :func:`metrics.homogeneity_score` +'mutual_info_score' :func:`metrics.mutual_info_score` +'normalized_mutual_info_score' :func:`metrics.normalized_mutual_info_score` +'v_measure_score' :func:`metrics.v_measure_score` Regression -'explained_variance' :func:`metrics.explained_variance_score` -'max_error' :func:`metrics.max_error` -'neg_mean_absolute_error' :func:`metrics.mean_absolute_error` -'neg_mean_squared_error' :func:`metrics.mean_squared_error` -'neg_root_mean_squared_error' :func:`metrics.mean_squared_error` -'neg_mean_squared_log_error' :func:`metrics.mean_squared_log_error` -'neg_median_absolute_error' :func:`metrics.median_absolute_error` -'r2' :func:`metrics.r2_score` -'neg_mean_poisson_deviance' :func:`metrics.mean_poisson_deviance` -'neg_mean_gamma_deviance' :func:`metrics.mean_gamma_deviance` -============================== ============================================= ================================== +'explained_variance' :func:`metrics.explained_variance_score` +'max_error' :func:`metrics.max_error` +'neg_mean_absolute_error' :func:`metrics.mean_absolute_error` +'neg_mean_squared_error' :func:`metrics.mean_squared_error` +'neg_root_mean_squared_error' :func:`metrics.mean_squared_error` +'neg_mean_squared_log_error' :func:`metrics.mean_squared_log_error` +'neg_median_absolute_error' :func:`metrics.median_absolute_error` +'r2' :func:`metrics.r2_score` +'neg_mean_poisson_deviance' :func:`metrics.mean_poisson_deviance` +'neg_mean_gamma_deviance' :func:`metrics.mean_gamma_deviance` +'neg_mean_absolute_percentage_error' :func:`metrics.mean_absolute_percentage_error` +==================================== ============================================== ================================== Usage examples: @@ -1963,6 +1964,42 @@ function:: >>> mean_squared_log_error(y_true, y_pred) 0.044... +.. _mean_absolute_percentage_error: + +Mean absolute percentage error +------------------------------ +The :func:`mean_absolute_percentage_error` (MAPE), also known as mean absolute +percentage deviation (MAPD), is an evaluation metric for regression problems. +The idea of this metric is to be sensitive to relative errors. It is for example +not changed by a global scaling of the target variable. + +If :math:`\hat{y}_i` is the predicted value of the :math:`i`-th sample +and :math:`y_i` is the corresponding true value, then the mean absolute percentage +error (MAPE) estimated over :math:`n_{\text{samples}}` is defined as + +.. math:: + + \text{MAPE}(y, \hat{y}) = \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}}-1} \frac{{}\left\| y_i - \hat{y}_i \right\|}{max(\epsilon, \left\| y_i \right\|)} + +where :math:`\epsilon` is an arbitrary small yet strictly positive number to +avoid undefined results when y is zero. + +The :func:`mean_absolute_percentage_error` function supports multioutput. + +Here is a small example of usage of the :func:`mean_absolute_percentage_error` +function:: + + >>> from sklearn.metrics import mean_absolute_percentage_error + >>> y_true = [1, 10, 1e6] + >>> y_pred = [0.9, 15, 1.2e6] + >>> mean_absolute_percentage_error(y_true, y_pred) + 0.2666... + +In above example, if we had used `mean_absolute_error`, it would have ignored +the small magnitude values and only reflected the error in prediction of highest +magnitude value. But that problem is resolved in case of MAPE because it calculates +relative percentage error with respect to actual output. + .. _median_absolute_error: Median absolute error diff --git a/doc/whats_new/_contributors.rst b/doc/whats_new/_contributors.rst index cc3957eca1592..ca0f8ede93afa 100644 --- a/doc/whats_new/_contributors.rst +++ b/doc/whats_new/_contributors.rst @@ -176,4 +176,4 @@ .. _Nicolas Hug: https://github.com/NicolasHug -.. _Guillaume Lemaitre: https://github.com/glemaitre +.. _Guillaume Lemaitre: https://github.com/glemaitre \ No newline at end of file diff --git a/doc/whats_new/v0.24.rst b/doc/whats_new/v0.24.rst index c41f761de1018..e637e367d401e 100644 --- a/doc/whats_new/v0.24.rst +++ b/doc/whats_new/v0.24.rst @@ -150,6 +150,12 @@ Changelog :mod:`sklearn.metrics` ...................... +- \|Feature\| Added :func:`metrics.mean_absolute_percentage_error` metric and + the associated scorer for regression problems. :issue:`10708` fixed with the + PR :pr:`15007` by :user:`Ashutosh Hathidara <ashutosh1919>`. The scorer and + some practical test cases were taken from PR :pr:`10711` by + :user:`Mohamed Ali Jamaoui <mohamed-ali>`. + - \|Fix\| Fixed a bug in :func:`metrics.mean_squared_error` where the average of multiple RMSE values was incorrectly calculated as the root of the average of multiple MSE values.	[ { "components": [ { "doc": "Mean absolute percentage error regression loss\n\nNote here that we do not represent the output as a percentage in range\n[0, 100]. Instead, we represent it in range [0, 1/eps]. Read more in the\n:ref:`User Guide <mean_absolute_percentage_error>`.\n\nParameters\n-------...	[ "sklearn/metrics/tests/test_common.py::test_symmetry_consistency", "sklearn/metrics/tests/test_common.py::test_symmetric_metric[accuracy_score]", "sklearn/metrics/tests/test_common.py::test_symmetric_metric[cohen_kappa_score]", "sklearn/metrics/tests/test_common.py::test_symmetric_metric[f1_score]", "sklear...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added mean_absolute_percentage_error in metrics fixes #10708 I have faced problem when working with any quantitative modelling algorithm. Scikit-learn doesn't have any function such mean_absolute_percentage_error. Everytime, when I want to use this function, then I have to implement it myself. But, if it is included in sklearn itself then it will be great. I have written code for this function and I have also added tests for it. @agramfort , Please Review my PR. ![mape](https://user-images.githubusercontent.com/20843596/65117948-26611180-da08-11e9-837d-68af24949e57.png) This PR Fixes #10708 . This PR is continuation of the work done by @mohamed-ali in #10711 PR. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/metrics/_regression.py] (definition of mean_absolute_percentage_error:) def mean_absolute_percentage_error(y_true, y_pred, sample_weight=None, multioutput='uniform_average'): """Mean absolute percentage error regression loss Note here that we do not represent the output as a percentage in range [0, 100]. Instead, we represent it in range [0, 1/eps]. Read more in the :ref:`User Guide <mean_absolute_percentage_error>`. Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. multioutput : {'raw_values', 'uniform_average'} or array-like Defines aggregating of multiple output values. Array-like value defines weights used to average errors. If input is list then the shape must be (n_outputs,). 'raw_values' : Returns a full set of errors in case of multioutput input. 'uniform_average' : Errors of all outputs are averaged with uniform weight. Returns ------- loss : float or ndarray of floats in the range [0, 1/eps] If multioutput is 'raw_values', then mean absolute percentage error is returned for each output separately. If multioutput is 'uniform_average' or an ndarray of weights, then the weighted average of all output errors is returned. MAPE output is non-negative floating point. The best value is 0.0. But note the fact that bad predictions can lead to arbitarily large MAPE values, especially if some y_true values are very close to zero. Note that we return a large value instead of `inf` when y_true is zero. Examples -------- >>> from sklearn.metrics import mean_absolute_percentage_error >>> y_true = [3, -0.5, 2, 7] >>> y_pred = [2.5, 0.0, 2, 8] >>> mean_absolute_percentage_error(y_true, y_pred) 0.3273... >>> y_true = [[0.5, 1], [-1, 1], [7, -6]] >>> y_pred = [[0, 2], [-1, 2], [8, -5]] >>> mean_absolute_percentage_error(y_true, y_pred) 0.5515... >>> mean_absolute_percentage_error(y_true, y_pred, multioutput=[0.3, 0.7]) 0.6198...""" [end of new definitions in sklearn/metrics/_regression.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Add MAPE as evaluation metric Also see #6605. https://en.wikipedia.org/wiki/Mean_absolute_percentage_error probably need a neg_mape scorer, too. ---------- @amueller, I'd like to work on this. sure, go for it. @amueller, all sklearn metrics have an output in the`[0,1]` interval. Is it okay that this metric will have its output in `[0,100]`? or should we not multiply with 100 and only keep the fraction? @mohamed-ali not all. MSE doesn't, for example (though I guess all with a fixed range do). I think we should multiply by 100 given that it's part of the definition, even though it's slightly different from other metrics. @amueller okay great. Thanks for the quick reply :) @amueller regarding the scorer, based on the deprecation message in the following example, I assume there should be a `neg_mean_absolute_percentage_error_scorer` instead of `mean_absolute_percentage_error_scorer`: ``` neg_mean_squared_error_scorer = make_scorer(mean_squared_error, greater_is_better=False) deprecation_msg = ('Scoring method mean_squared_error was renamed to ' 'neg_mean_squared_error in version 0.18 and will ' 'be removed in 0.20.') mean_squared_error_scorer = make_scorer(mean_squared_error, greater_is_better=False) ``` https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/metrics/scorer.py#L472-L497 Is my assumption correct? if we call it mean_absolute_proportion_error we don't need the 100x yes, for the scorer, it should be neg_, but for the metric it should not. Andy proposed the scorer name neg_mape above @amueller & @jnothman, I pushed the work in progress at this pull request https://github.com/scikit-learn/scikit-learn/pull/10711. We can move the discussion there and probably vote with the core devs on right name to consider. @amueller & @jnothman, the work is done in https://github.com/scikit-learn/scikit-learn/pull/10711. Could you please do a full review? Thanks. @amueller @jnothman, out of curiosity, why do we prefix the scorer name with `neg_`? because the score is negated to follow the convention that greater is better. but users complained when we negated it without signifying so in the name @jnothman thank you! -------------------- </issues>	54ce4222694819ad52d544ce5cba5da274c34ab7
sympy__sympy-17617	17,617	sympy/sympy	1.5	def1c20c221f0bdf7feaaac7b4cd54a42bf57db7	2019-09-16T17:49:23Z	diff --git a/doc/src/modules/crypto.rst b/doc/src/modules/crypto.rst index 14aabee76638..43a916b64797 100644 --- a/doc/src/modules/crypto.rst +++ b/doc/src/modules/crypto.rst @@ -142,3 +142,7 @@ substitutions at different times in the message. .. autofunction:: encipher_gm .. autofunction:: decipher_gm + +.. autofunction:: encipher_railfence + +.. autofunction:: decipher_railfence diff --git a/sympy/crypto/__init__.py b/sympy/crypto/__init__.py index 0ba69df2379f..3896e8943c9d 100644 --- a/sympy/crypto/__init__.py +++ b/sympy/crypto/__init__.py @@ -12,4 +12,5 @@ padded_key, encipher_bifid, decipher_bifid, bifid_square, bifid5, bifid6, bifid10, decipher_gm, encipher_gm, gm_public_key, gm_private_key, bg_private_key, bg_public_key, encipher_bg, decipher_bg, - encipher_rot13, decipher_rot13, encipher_atbash, decipher_atbash) + encipher_rot13, decipher_rot13, encipher_atbash, decipher_atbash, + encipher_railfence, decipher_railfence) diff --git a/sympy/crypto/crypto.py b/sympy/crypto/crypto.py index af060dbfcfcf..4f97162d48ee 100644 --- a/sympy/crypto/crypto.py +++ b/sympy/crypto/crypto.py @@ -20,6 +20,8 @@ from functools import reduce import warnings +from itertools import cycle + from sympy import nextprime from sympy.core import Rational, Symbol from sympy.core.numbers import igcdex, mod_inverse, igcd @@ -2699,7 +2701,7 @@ def decipher_elgamal(msg, key): True """ - p, r, d = key + p, _, d = key c1, c2 = msg u = igcdex(c1*d, p)[0] return u c2 % p @@ -3069,6 +3071,76 @@ def decipher_gm(message, key): m += not b return m + + +########### RailFence Cipher ############# + +def encipher_railfence(message,rails): + """ + Performs Railfence Encryption on plaintext and returns ciphertext + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_railfence + >>> message = "hello world" + >>> encipher_railfence(message,3) + 'horel ollwd' + + Parameters + ========== + + message : string, the message to encrypt. + rails : int, the number of rails. + + Returns + ======= + + The Encrypted string message. + + References + ========== + .. [1] https://en.wikipedia.org/wiki/Rail_fence_cipher + + """ + r = list(range(rails)) + p = cycle(r + r[-2:0:-1]) + return ''.join(sorted(message, key=lambda i: next(p))) + + +def decipher_railfence(ciphertext,rails): + """ + Decrypt the message using the given rails + + Examples + ======== + + >>> from sympy.crypto.crypto import decipher_railfence + >>> decipher_railfence("horel ollwd",3) + 'hello world' + + Parameters + ========== + + message : string, the message to encrypt. + rails : int, the number of rails. + + Returns + ======= + + The Decrypted string message. + + """ + r = list(range(rails)) + p = cycle(r + r[-2:0:-1]) + + idx = sorted(range(len(ciphertext)), key=lambda i: next(p)) + res = [''] * len(ciphertext) + for i, c in zip(idx, ciphertext): + res[i] = c + return ''.join(res) + + ################ Blum–Goldwasser cryptosystem ######################### def bg_private_key(p, q): @@ -3193,7 +3265,7 @@ def encipher_bg(i, key, seed=None): x_L = pow(int(x), int(2L), int(key)) rand_bits = [] - for k in range(L): + for _ in range(L): rand_bits.append(x % 2) x = x2 % key @@ -3244,7 +3316,7 @@ def decipher_bg(message, key): x = (q * mod_inverse(q, p) * r_p + p * mod_inverse(p, q) * r_q) % public_key orig_bits = [] - for k in range(L): + for _ in range(L): orig_bits.append(x % 2) x = x**2 % public_key	diff --git a/sympy/crypto/tests/test_crypto.py b/sympy/crypto/tests/test_crypto.py index 0ada73f7e513..0711874c361b 100644 --- a/sympy/crypto/tests/test_crypto.py +++ b/sympy/crypto/tests/test_crypto.py @@ -15,7 +15,8 @@ decipher_bifid, bifid_square, padded_key, uniq, decipher_gm, encipher_gm, gm_public_key, gm_private_key, encipher_bg, decipher_bg, bg_private_key, bg_public_key, encipher_rot13, decipher_rot13, - encipher_atbash, decipher_atbash, NonInvertibleCipherWarning) + encipher_atbash, decipher_atbash, NonInvertibleCipherWarning, + encipher_railfence, decipher_railfence) from sympy.matrices import Matrix from sympy.ntheory import isprime, is_primitive_root from sympy.polys.domains import FF @@ -24,6 +25,16 @@ from random import randrange +def test_encipher_railfence(): + assert encipher_railfence("hello world",2) == "hlowrdel ol" + assert encipher_railfence("hello world",3) == "horel ollwd" + assert encipher_railfence("hello world",4) == "hwe olordll" + +def test_decipher_railfence(): + assert decipher_railfence("hlowrdel ol",2) == "hello world" + assert decipher_railfence("horel ollwd",3) == "hello world" + assert decipher_railfence("hwe olordll",4) == "hello world" + def test_cycle_list(): assert cycle_list(3, 4) == [3, 0, 1, 2]	diff --git a/doc/src/modules/crypto.rst b/doc/src/modules/crypto.rst index 14aabee76638..43a916b64797 100644 --- a/doc/src/modules/crypto.rst +++ b/doc/src/modules/crypto.rst @@ -142,3 +142,7 @@ substitutions at different times in the message. .. autofunction:: encipher_gm .. autofunction:: decipher_gm + +.. autofunction:: encipher_railfence + +.. autofunction:: decipher_railfence	[ { "components": [ { "doc": "Performs Railfence Encryption on plaintext and returns ciphertext\n\nExamples\n========\n\n>>> from sympy.crypto.crypto import encipher_railfence\n>>> message = \"hello world\"\n>>> encipher_railfence(message,3)\n'horel ollwd'\n\nParameters\n==========\n\nmessage : stri...	[ "test_encipher_railfence", "test_decipher_railfence", "test_cycle_list", "test_encipher_shift", "test_encipher_rot13", "test_encipher_affine", "test_encipher_atbash", "test_encipher_substitution", "test_check_and_join", "test_encipher_vigenere", "test_decipher_vigenere", "test_encipher_hill", ...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added Rail Fence Cipher <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> Closes #15789 Closes #15534 #### Brief description of what is fixed or changed #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * crypto * Rail fence cipher has been added to `sympy.crypto.crypto` <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/crypto/crypto.py] (definition of encipher_railfence:) def encipher_railfence(message,rails): """Performs Railfence Encryption on plaintext and returns ciphertext Examples ======== >>> from sympy.crypto.crypto import encipher_railfence >>> message = "hello world" >>> encipher_railfence(message,3) 'horel ollwd' Parameters ========== message : string, the message to encrypt. rails : int, the number of rails. Returns ======= The Encrypted string message. References ========== .. [1] https://en.wikipedia.org/wiki/Rail_fence_cipher""" (definition of decipher_railfence:) def decipher_railfence(ciphertext,rails): """Decrypt the message using the given rails Examples ======== >>> from sympy.crypto.crypto import decipher_railfence >>> decipher_railfence("horel ollwd",3) 'hello world' Parameters ========== message : string, the message to encrypt. rails : int, the number of rails. Returns ======= The Decrypted string message.""" [end of new definitions in sympy/crypto/crypto.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Added RailFence cipher Updated and Added New RailFence cipher <!-- BEGIN RELEASE NOTES --> * crypto * Added railfence cipher <!-- END RELEASE NOTES --> ---------- -------------------- </issues>	c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-17615	17,615	sympy/sympy	1.5	2d700c4b3c0871a26741456787b0555eed9d5546	2019-09-14T08:32:47Z	diff --git a/sympy/functions/special/gamma_functions.py b/sympy/functions/special/gamma_functions.py index 5a94e17adcc3..a05d3ee6f986 100644 --- a/sympy/functions/special/gamma_functions.py +++ b/sympy/functions/special/gamma_functions.py @@ -992,7 +992,7 @@ def _sage_(self): return sage.log_gamma(self.args[0]._sage_()) -def digamma(x): +class digamma(Function): r""" The digamma function is the first derivative of the loggamma function i.e, @@ -1020,10 +1020,52 @@ def digamma(x): .. [2] http://mathworld.wolfram.com/DigammaFunction.html .. [3] http://functions.wolfram.com/GammaBetaErf/PolyGamma2/ """ - return polygamma(0, x) + def _eval_evalf(self, prec): + z = self.args[0] + return polygamma(0, z).evalf(prec) + + def fdiff(self, argindex=1): + z = self.args[0] + return polygamma(0, z).fdiff() + + def _eval_is_real(self): + z = self.args[0] + return polygamma(0, z).is_real + def _eval_is_positive(self): + z = self.args[0] + return polygamma(0, z).is_positive + + def _eval_is_negative(self): + z = self.args[0] + return polygamma(0, z).is_negative + + def _eval_aseries(self, n, args0, x, logx): + as_polygamma = self.rewrite(polygamma) + args0 = [S.Zero,] + args0 + return as_polygamma._eval_aseries(n, args0, x, logx) -def trigamma(x): + @classmethod + def eval(cls, z): + return polygamma(0, z) + + def _eval_expand_func(self, hints): + z = self.args[0] + return polygamma(0, z).expand(func=True) + + def _eval_rewrite_as_harmonic(self, z, kwargs): + return harmonic(z - 1) - S.EulerGamma + + def _eval_rewrite_as_polygamma(self, z, kwargs): + return polygamma(0, z) + + def _eval_as_leading_term(self, x): + z = self.args[0] + return polygamma(0, z).as_leading_term(x) + + + +class trigamma(Function): r""" The trigamma function is the second derivative of the loggamma function i.e, @@ -1050,7 +1092,52 @@ def trigamma(x): .. [2] http://mathworld.wolfram.com/TrigammaFunction.html .. [3] http://functions.wolfram.com/GammaBetaErf/PolyGamma2/ """ - return polygamma(1, x) + def _eval_evalf(self, prec): + z = self.args[0] + return polygamma(1, z).evalf(prec) + + def fdiff(self, argindex=1): + z = self.args[0] + return polygamma(1, z).fdiff() + + def _eval_is_real(self): + z = self.args[0] + return polygamma(1, z).is_real + + def _eval_is_positive(self): + z = self.args[0] + return polygamma(1, z).is_positive + + def _eval_is_negative(self): + z = self.args[0] + return polygamma(1, z).is_negative + + def _eval_aseries(self, n, args0, x, logx): + as_polygamma = self.rewrite(polygamma) + args0 = [S.One,] + args0 + return as_polygamma._eval_aseries(n, args0, x, logx) + + @classmethod + def eval(cls, z): + return polygamma(1, z) + + def _eval_expand_func(self, hints): + z = self.args[0] + return polygamma(1, z).expand(func=True) + + def _eval_rewrite_as_zeta(self, z, kwargs): + return zeta(2, z) + + def _eval_rewrite_as_polygamma(self, z, kwargs): + return polygamma(1, z) + + def _eval_rewrite_as_harmonic(self, z, kwargs): + return -harmonic(z - 1, 2) + S.Pi2 / 6 + + def _eval_as_leading_term(self, x): + z = self.args[0] + return polygamma(1, z).as_leading_term(x) + ############################################################################### ##################### COMPLETE MULTIVARIATE GAMMA FUNCTION ####################	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index a8e3d511bc84..67ee3df3e9f7 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -2288,6 +2288,13 @@ def test_sympy__functions__special__gamma_functions__polygamma(): from sympy.functions.special.gamma_functions import polygamma assert _test_args(polygamma(x, 2)) +def test_sympy__functions__special__gamma_functions__digamma(): + from sympy.functions.special.gamma_functions import digamma + assert _test_args(digamma(x)) + +def test_sympy__functions__special__gamma_functions__trigamma(): + from sympy.functions.special.gamma_functions import trigamma + assert _test_args(trigamma(x)) def test_sympy__functions__special__gamma_functions__uppergamma(): from sympy.functions.special.gamma_functions import uppergamma diff --git a/sympy/functions/special/tests/test_beta_functions.py b/sympy/functions/special/tests/test_beta_functions.py index 3c23ac4e10af..fc19f1ed35d9 100644 --- a/sympy/functions/special/tests/test_beta_functions.py +++ b/sympy/functions/special/tests/test_beta_functions.py @@ -1,4 +1,5 @@ from sympy import (Symbol, gamma, expand_func, beta, digamma, diff, conjugate) +from sympy.functions.special.gamma_functions import polygamma from sympy.core.function import ArgumentIndexError from sympy.utilities.pytest import raises @@ -12,8 +13,8 @@ def test_beta(): assert expand_func(beta(x, y) - beta(y, x)) == 0 # Symmetric assert expand_func(beta(x, y)) == expand_func(beta(x, y + 1) + beta(x + 1, y)).simplify() - assert diff(beta(x, y), x) == beta(x, y)(digamma(x) - digamma(x + y)) - assert diff(beta(x, y), y) == beta(x, y)(digamma(y) - digamma(x + y)) + assert diff(beta(x, y), x) == beta(x, y)(polygamma(0, x) - polygamma(0, x + y)) + assert diff(beta(x, y), y) == beta(x, y)(polygamma(0, y) - polygamma(0, x + y)) assert conjugate(beta(x, y)) == beta(conjugate(x), conjugate(y)) diff --git a/sympy/functions/special/tests/test_gamma_functions.py b/sympy/functions/special/tests/test_gamma_functions.py index 5acabb14425e..5cc70ea9275b 100644 --- a/sympy/functions/special/tests/test_gamma_functions.py +++ b/sympy/functions/special/tests/test_gamma_functions.py @@ -1,6 +1,6 @@ from sympy import ( Symbol, Dummy, gamma, I, oo, nan, zoo, factorial, sqrt, Rational, - multigamma, log, polygamma, EulerGamma, pi, uppergamma, S, expand_func, + multigamma, log, polygamma, digamma, trigamma, EulerGamma, pi, uppergamma, S, expand_func, loggamma, sin, cos, O, lowergamma, exp, erf, erfc, exp_polar, harmonic, zeta, conjugate, Ei, im, re, tanh, Abs) @@ -114,7 +114,7 @@ def test_lowergamma(): assert td(lowergamma(randcplx(), y), y) assert td(lowergamma(x, randcplx()), x) assert lowergamma(x, y).diff(x) == \ - gamma(x)polygamma(0, x) - uppergamma(x, y)log(y) \ + gamma(x)digamma(x) - uppergamma(x, y)log(y) \ - meijerg([], [1, 1], [0, 0, x], [], y) assert lowergamma(S.Half, x) == sqrt(pi)erf(sqrt(x)) @@ -367,6 +367,119 @@ def test_polygamma_expand_func(): e = polygamma(3, x + y + S(3)/4) assert e.expand(func=True, basic=False) == e +def test_digamma(): + from sympy import I + + assert digamma(nan) == nan + + assert digamma(oo) == oo + assert digamma(-oo) == oo + assert digamma(Ioo) == oo + assert digamma(-Ioo) == oo + + assert digamma(-9) == zoo + + assert digamma(-9) == zoo + assert digamma(-1) == zoo + + assert digamma(0) == zoo + + assert digamma(1) == -EulerGamma + assert digamma(7) == Rational(49, 20) - EulerGamma + + def t(m, n): + x = S(m)/n + r = digamma(x) + if r.has(digamma): + return False + return abs(digamma(x.n()).n() - r.n()).n() < 1e-10 + assert t(1, 2) + assert t(3, 2) + assert t(-1, 2) + assert t(1, 4) + assert t(-3, 4) + assert t(1, 3) + assert t(4, 3) + assert t(3, 4) + assert t(2, 3) + assert t(123, 5) + + assert digamma(x).rewrite(zeta) == polygamma(0, x) + + assert digamma(x).rewrite(harmonic) == harmonic(x - 1) - EulerGamma + + assert digamma(I).is_real is None + + assert digamma(x,evaluate=False).fdiff() == polygamma(1, x) + + assert digamma(x,evaluate=False).is_real is None + + assert digamma(x,evaluate=False).is_positive is None + + assert digamma(x,evaluate=False).is_negative is None + + assert digamma(x,evaluate=False).rewrite(polygamma) == polygamma(0, x) + + +def test_digamma_expand_func(): + assert digamma(x).expand(func=True) == polygamma(0, x) + assert digamma(2x).expand(func=True) == \ + polygamma(0, x)/2 + polygamma(0, Rational(1, 2) + x)/2 + log(2) + assert digamma(-1 + x).expand(func=True) == \ + polygamma(0, x) - 1/(x - 1) + assert digamma(1 + x).expand(func=True) == \ + 1/x + polygamma(0, x ) + assert digamma(2 + x).expand(func=True) == \ + 1/x + 1/(1 + x) + polygamma(0, x) + assert digamma(3 + x).expand(func=True) == \ + polygamma(0, x) + 1/x + 1/(1 + x) + 1/(2 + x) + assert digamma(4 + x).expand(func=True) == \ + polygamma(0, x) + 1/x + 1/(1 + x) + 1/(2 + x) + 1/(3 + x) + assert digamma(x + y).expand(func=True) == \ + polygamma(0, x + y) + +def test_trigamma(): + from sympy import I + + assert trigamma(nan) == nan + + assert trigamma(oo) == 0 + + assert trigamma(1) == pi2/6 + assert trigamma(2) == pi2/6 - 1 + assert trigamma(3) == pi*2/6 - Rational(5, 4) + + assert trigamma(x, evaluate=False).rewrite(zeta) == zeta(2, x) + assert trigamma(x, evaluate=False).rewrite(harmonic) == \ + trigamma(x).rewrite(polygamma).rewrite(harmonic) + + assert trigamma(x,evaluate=False).fdiff() == polygamma(2, x) + + assert trigamma(x,evaluate=False).is_real is None + + assert trigamma(x,evaluate=False).is_positive is None + + assert trigamma(x,evaluate=False).is_negative is None + + assert trigamma(x,evaluate=False).rewrite(polygamma) == polygamma(1, x) + +def test_trigamma_expand_func(): + assert trigamma(2x).expand(func=True) == \ + polygamma(1, x)/4 + polygamma(1, Rational(1, 2) + x)/4 + assert trigamma(1 + x).expand(func=True) == \ + polygamma(1, x) - 1/x2 + assert trigamma(2 + x).expand(func=True, multinomial=False) == \ + polygamma(1, x) - 1/x2 - 1/(1 + x)2 + assert trigamma(3 + x).expand(func=True, multinomial=False) == \ + polygamma(1, x) - 1/x2 - 1/(1 + x)2 - 1/(2 + x)2 + assert trigamma(4 + x).expand(func=True, multinomial=False) == \ + polygamma(1, x) - 1/x2 - 1/(1 + x)2 - \ + 1/(2 + x)2 - 1/(3 + x)2 + assert trigamma(x + y).expand(func=True) == \ + polygamma(1, x + y) + assert trigamma(3 + 4x + y).expand(func=True, multinomial=False) == \ + polygamma(1, y + 4x) - 1/(y + 4x)2 - \ + 1/(1 + y + 4x)*2 - 1/(2 + y + 4x)**2 def test_loggamma(): raises(TypeError, lambda: loggamma(2, 3))		[ { "components": [ { "doc": "", "lines": [ 1023, 1025 ], "name": "digamma._eval_evalf", "signature": "def _eval_evalf(self, prec):", "type": "function" }, { "doc": "", "lines": [ 1027, 1029 ...	[ "test_digamma", "test_trigamma" ]	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Implement digamma and trigamma functions as Function subclasses <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> Fixes #17596 #### Brief description of what is fixed or changed The digamma and trigamma functions were Python functions. Now they are Function subclasses #### Other comments Added tests for digamma and trigamma #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * functions * made digamma and trigamma into Function subclasses <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/functions/special/gamma_functions.py] (definition of digamma._eval_evalf:) def _eval_evalf(self, prec): (definition of digamma.fdiff:) def fdiff(self, argindex=1): (definition of digamma._eval_is_real:) def _eval_is_real(self): (definition of digamma._eval_is_positive:) def _eval_is_positive(self): (definition of digamma._eval_is_negative:) def _eval_is_negative(self): (definition of digamma._eval_aseries:) def _eval_aseries(self, n, args0, x, logx): (definition of digamma.eval:) def eval(cls, z): (definition of digamma._eval_expand_func:) def _eval_expand_func(self, hints): (definition of digamma._eval_rewrite_as_harmonic:) def _eval_rewrite_as_harmonic(self, z, kwargs): (definition of digamma._eval_rewrite_as_polygamma:) def _eval_rewrite_as_polygamma(self, z, kwargs): (definition of digamma._eval_as_leading_term:) def _eval_as_leading_term(self, x): (definition of trigamma._eval_evalf:) def _eval_evalf(self, prec): (definition of trigamma.fdiff:) def fdiff(self, argindex=1): (definition of trigamma._eval_is_real:) def _eval_is_real(self): (definition of trigamma._eval_is_positive:) def _eval_is_positive(self): (definition of trigamma._eval_is_negative:) def _eval_is_negative(self): (definition of trigamma._eval_aseries:) def _eval_aseries(self, n, args0, x, logx): (definition of trigamma.eval:) def eval(cls, z): (definition of trigamma._eval_expand_func:) def _eval_expand_func(self, hints): (definition of trigamma._eval_rewrite_as_zeta:) def _eval_rewrite_as_zeta(self, z, kwargs): (definition of trigamma._eval_rewrite_as_polygamma:) def _eval_rewrite_as_polygamma(self, z, kwargs): (definition of trigamma._eval_rewrite_as_harmonic:) def _eval_rewrite_as_harmonic(self, z, **kwargs): (definition of trigamma._eval_as_leading_term:) def _eval_as_leading_term(self, x): [end of new definitions in sympy/functions/special/gamma_functions.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> digamma and trigamma should be Function subclasses Right now `digamma` and `trigamma` are Python functions. They should be Function subclasses, so they can be unevaluated. ---------- I'd like to work on this issue. -------------------- </issues>	c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-17581	17,581	sympy/sympy	1.5	f5e965947af2410ded92cfad987aaf45262ea434	2019-09-05T19:19:27Z	diff --git a/doc/src/modules/sets.rst b/doc/src/modules/sets.rst index 35a8a8910eb9..d87a4b2f3bdf 100644 --- a/doc/src/modules/sets.rst +++ b/doc/src/modules/sets.rst @@ -2,6 +2,9 @@ Sets ==== +Basic Sets +---------- + .. automodule:: sympy.sets.sets Set @@ -24,8 +27,20 @@ FiniteSet .. autoclass:: FiniteSet :members: +ConditionSet +^^^^^^^^^^^^ +.. module:: sympy.sets.conditionset + :noindex: + +.. autoclass:: ConditionSet + :members: + Compound Sets ------------- + +.. module:: sympy.sets.sets + :noindex: + Union ^^^^^ .. autoclass:: Union @@ -46,6 +61,11 @@ Complement .. autoclass:: Complement :members: +SymmetricDifference +^^^^^^^^^^^^^^^^^^^ +.. autoclass:: SymmetricDifference + :members: + Singleton Sets -------------- @@ -95,6 +115,16 @@ ComplexRegion .. autofunction:: normalize_theta_set +Power sets +---------- + +.. automodule:: sympy.sets.powerset + +PowerSet +^^^^^^^^ +.. autoclass:: PowerSet + :members: + Iteration over sets ^^^^^^^^^^^^^^^^^^^ diff --git a/sympy/sets/__init__.py b/sympy/sets/__init__.py index a66ce07138aa..c3c400e9ae84 100644 --- a/sympy/sets/__init__.py +++ b/sympy/sets/__init__.py @@ -4,6 +4,7 @@ from .contains import Contains from .conditionset import ConditionSet from .ordinals import Ordinal, OmegaPower, ord0 +from .powerset import PowerSet from ..core.singleton import S Reals = S.Reals Naturals = S.Naturals diff --git a/sympy/sets/powerset.py b/sympy/sets/powerset.py new file mode 100644 index 000000000000..3722f5da35ca --- /dev/null +++ b/sympy/sets/powerset.py @@ -0,0 +1,116 @@ +from __future__ import print_function, division + +from sympy.core.decorators import _sympifyit +from sympy.core.evaluate import global_evaluate +from sympy.core.logic import fuzzy_bool +from sympy.core.singleton import S +from sympy.core.sympify import _sympify + +from .sets import Set, tfn + + +class PowerSet(Set): + r"""A symbolic object representing a power set. + + Parameters + ========== + + arg : Set + The set to take power of. + + evaluate : bool + The flag to control evaluation. + + If the evaluation is disabled for finite sets, it can take + advantage of using subset test as a membership test. + + Notes + ===== + + Power set `\mathcal{P}(S)` is defined as a set containing all the + subsets of `S`. + + If the set `S` is a finite set, its power set would have + `2^{\left\| S \right\|}` elements, where `\left\| S \right\|` denotes + the cardinality of `S`. + + Examples + ======== + + >>> from sympy.sets.powerset import PowerSet + >>> from sympy import S, FiniteSet + + A power set of a finite set: + + >>> PowerSet(FiniteSet(1, 2, 3)) + PowerSet({1, 2, 3}) + + A power set of an empty set: + + >>> PowerSet(S.EmptySet) + PowerSet(EmptySet()) + >>> PowerSet(PowerSet(S.EmptySet)) + PowerSet(PowerSet(EmptySet())) + + A power set of an infinite set: + + >>> PowerSet(S.Reals) + PowerSet(Reals) + + Evaluating the power set of a finite set to its explicit form: + + >>> PowerSet(FiniteSet(1, 2, 3)).rewrite(FiniteSet) + {EmptySet(), {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}} + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Power_set + + .. [2] https://en.wikipedia.org/wiki/Axiom_of_power_set + """ + def __new__(cls, arg, evaluate=global_evaluate[0]): + arg = _sympify(arg) + + if not isinstance(arg, Set): + raise ValueError('{} must be a set.'.format(arg)) + + return super(PowerSet, cls).__new__(cls, arg) + + @property + def arg(self): + return self.args[0] + + def _eval_rewrite_as_FiniteSet(self, args, kwargs): + arg = self.arg + if arg.is_FiniteSet: + return arg.powerset() + return None + + @_sympifyit('other', NotImplemented) + def _contains(self, other): + if not isinstance(other, Set): + return None + + return fuzzy_bool(self.arg.is_superset(other)) + + def _eval_is_subset(self, other): + if isinstance(other, PowerSet): + return self.arg.is_subset(other.arg) + + def __len__(self): + return 2 * len(self.arg) + + def __iter__(self): + from .sets import FiniteSet + found = [S.EmptySet] + yield S.EmptySet + + for x in self.arg: + temp = [] + x = FiniteSet(x) + for y in found: + new = x + y + yield new + temp.append(new) + found.extend(temp) diff --git a/sympy/sets/sets.py b/sympy/sets/sets.py index ef8a957043df..d609dcc04ab8 100644 --- a/sympy/sets/sets.py +++ b/sympy/sets/sets.py @@ -366,6 +366,12 @@ def is_subset(self, other): """ if isinstance(other, Set): + dispatch = getattr(self, '_eval_is_subset', None) + if dispatch is not None: + ret = dispatch(other) + if ret is not None: + return ret + s_o = self.intersect(other) if s_o == self: return True @@ -448,7 +454,7 @@ def is_proper_superset(self, other): raise ValueError("Unknown argument '%s'" % other) def _eval_powerset(self): - raise NotImplementedError('Power set not defined for: %s' % self.func) + return None def powerset(self): """ @@ -1832,6 +1838,25 @@ def _sorted_args(self): def _eval_powerset(self): return self.func([self.func(s) for s in subsets(self.args)]) + def _eval_rewrite_as_PowerSet(self, args, kwargs): + """Rewriting method for a finite set to a power set.""" + from .powerset import PowerSet + + is2pow = lambda n: bool(n and not n & (n - 1)) + if not is2pow(len(self)): + return None + + fs_test = lambda arg: isinstance(arg, Set) and arg.is_FiniteSet + if not all((fs_test(arg) for arg in args)): + return None + + biggest = max(args, key=len) + for arg in subsets(biggest.args): + arg_set = FiniteSet(arg) + if arg_set not in args: + return None + return PowerSet(biggest) + def __ge__(self, other): if not isinstance(other, Set): raise TypeError("Invalid comparison of set with %s" % func_name(other))	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 3373c913ab74..5171802bf931 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -823,6 +823,13 @@ def test_sympy__sets__ordinals__OrdinalZero(): from sympy.sets.ordinals import OrdinalZero assert _test_args(OrdinalZero()) + +def test_sympy__sets__powerset__PowerSet(): + from sympy.sets.powerset import PowerSet + from sympy.core.singleton import S + assert _test_args(PowerSet(S.EmptySet)) + + def test_sympy__sets__sets__EmptySet(): from sympy.sets.sets import EmptySet assert _test_args(EmptySet()) diff --git a/sympy/sets/tests/test_powerset.py b/sympy/sets/tests/test_powerset.py new file mode 100644 index 000000000000..2091af405254 --- /dev/null +++ b/sympy/sets/tests/test_powerset.py @@ -0,0 +1,116 @@ +from sympy.core.expr import unchanged +from sympy.core.singleton import S +from sympy.core.symbol import Symbol +from sympy.sets.contains import Contains +from sympy.sets.powerset import PowerSet +from sympy.sets.sets import FiniteSet +from sympy.utilities.pytest import raises, XFAIL + + +def test_powerset_creation(): + assert unchanged(PowerSet, FiniteSet(1, 2)) + assert unchanged(PowerSet, S.EmptySet) + raises(ValueError, lambda: PowerSet(123)) + assert unchanged(PowerSet, S.Reals) + assert unchanged(PowerSet, S.Integers) + + +def test_powerset_rewrite_FiniteSet(): + assert PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet) == \ + FiniteSet(S.EmptySet, FiniteSet(1), FiniteSet(2), FiniteSet(1, 2)) + assert PowerSet(S.EmptySet).rewrite(FiniteSet) == FiniteSet(S.EmptySet) + assert PowerSet(S.Naturals).rewrite(FiniteSet) == PowerSet(S.Naturals) + + +def test_finiteset_rewrite_powerset(): + assert FiniteSet(S.EmptySet).rewrite(PowerSet) == PowerSet(S.EmptySet) + assert FiniteSet( + S.EmptySet, FiniteSet(1), + FiniteSet(2), FiniteSet(1, 2)).rewrite(PowerSet) == \ + PowerSet(FiniteSet(1, 2)) + assert FiniteSet(1, 2, 3).rewrite(PowerSet) == FiniteSet(1, 2, 3) + + +def test_powerset__contains__(): + subset_series = [ + S.EmptySet, + FiniteSet(1, 2), + S.Naturals, + S.Naturals0, + S.Integers, + S.Rationals, + S.Reals, + S.Complexes] + + l = len(subset_series) + for i in range(l): + for j in range(l): + try: + if i <= j: + assert subset_series[i] in \ + PowerSet(subset_series[j], evaluate=False) + else: + assert subset_series[i] not in \ + PowerSet(subset_series[j], evaluate=False) + except: + raise AssertionError( + 'Powerset membership test failed between ' + '{} and {}.'.format(subset_series[i], subset_series[j])) + + +@XFAIL +def test_failing_powerset__contains__(): + # XXX These are failing when evaluate=True, + # but using unevaluated PowerSet works fine. + assert FiniteSet(1, 2) not in PowerSet(S.EmptySet).rewrite(FiniteSet) + assert S.Naturals not in PowerSet(S.EmptySet).rewrite(FiniteSet) + assert S.Naturals not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet) + assert S.Naturals0 not in PowerSet(S.EmptySet).rewrite(FiniteSet) + assert S.Naturals0 not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet) + assert S.Integers not in PowerSet(S.EmptySet).rewrite(FiniteSet) + assert S.Integers not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet) + assert S.Rationals not in PowerSet(S.EmptySet).rewrite(FiniteSet) + assert S.Rationals not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet) + assert S.Reals not in PowerSet(S.EmptySet).rewrite(FiniteSet) + assert S.Reals not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet) + assert S.Complexes not in PowerSet(S.EmptySet).rewrite(FiniteSet) + assert S.Complexes not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet) + + +def test_powerset__len__(): + A = PowerSet(S.EmptySet, evaluate=False) + assert len(A) == 1 + A = PowerSet(A, evaluate=False) + assert len(A) == 2 + A = PowerSet(A, evaluate=False) + assert len(A) == 4 + A = PowerSet(A, evaluate=False) + assert len(A) == 16 + + +def test_powerset__iter__(): + a = PowerSet(FiniteSet(1, 2)).__iter__() + assert next(a) == S.EmptySet + assert next(a) == FiniteSet(1) + assert next(a) == FiniteSet(2) + assert next(a) == FiniteSet(1, 2) + + a = PowerSet(S.Naturals).__iter__() + assert next(a) == S.EmptySet + assert next(a) == FiniteSet(1) + assert next(a) == FiniteSet(2) + assert next(a) == FiniteSet(1, 2) + assert next(a) == FiniteSet(3) + assert next(a) == FiniteSet(1, 3) + assert next(a) == FiniteSet(2, 3) + assert next(a) == FiniteSet(1, 2, 3) + + +def test_powerset_contains(): + A = PowerSet(FiniteSet(1), evaluate=False) + assert A.contains(2) == Contains(2, A) + + x = Symbol('x') + + A = PowerSet(FiniteSet(x), evaluate=False) + assert A.contains(FiniteSet(1)) == Contains(FiniteSet(1), A) diff --git a/sympy/sets/tests/test_sets.py b/sympy/sets/tests/test_sets.py index 014597828bcc..8afd13c59fd2 100644 --- a/sympy/sets/tests/test_sets.py +++ b/sympy/sets/tests/test_sets.py @@ -892,7 +892,6 @@ def test_powerset(): FiniteSet(2), A) # Not finite sets I = Interval(0, 1) - raises(NotImplementedError, I.powerset) def test_product_basic():	diff --git a/doc/src/modules/sets.rst b/doc/src/modules/sets.rst index 35a8a8910eb9..d87a4b2f3bdf 100644 --- a/doc/src/modules/sets.rst +++ b/doc/src/modules/sets.rst @@ -2,6 +2,9 @@ Sets ==== +Basic Sets +---------- + .. automodule:: sympy.sets.sets Set @@ -24,8 +27,20 @@ FiniteSet .. autoclass:: FiniteSet :members: +ConditionSet +^^^^^^^^^^^^ +.. module:: sympy.sets.conditionset + :noindex: + +.. autoclass:: ConditionSet + :members: + Compound Sets ------------- + +.. module:: sympy.sets.sets + :noindex: + Union ^^^^^ .. autoclass:: Union @@ -46,6 +61,11 @@ Complement .. autoclass:: Complement :members: +SymmetricDifference +^^^^^^^^^^^^^^^^^^^ +.. autoclass:: SymmetricDifference + :members: + Singleton Sets -------------- @@ -95,6 +115,16 @@ ComplexRegion .. autofunction:: normalize_theta_set +Power sets +---------- + +.. automodule:: sympy.sets.powerset + +PowerSet +^^^^^^^^ +.. autoclass:: PowerSet + :members: + Iteration over sets ^^^^^^^^^^^^^^^^^^^	[ { "components": [ { "doc": "A symbolic object representing a power set.\n\nParameters\n==========\n\narg : Set\n The set to take power of.\n\nevaluate : bool\n The flag to control evaluation.\n\n If the evaluation is disabled for finite sets, it can take\n advantage of using subset tes...	[ "test_sympy__sets__powerset__PowerSet", "test_powerset_creation", "test_powerset_rewrite_FiniteSet", "test_finiteset_rewrite_powerset", "test_powerset__contains__", "test_powerset__len__", "test_powerset__iter__" ]	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add power set notation <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed The previous implementation in #7329 have some limitations that it can only be applicable for finite sets, and generally, computation can be slow even for a handful of elements. I've added a full symbolic representation to resolve such issues. I also think that using powerset can resolve failings like `FiniteSet(1, 2) not in FiniteSet(S.EmptySet)` because it can use subset testing for membership testing. #### Other comments I've also fixed the rst section ordering, added missing docs for some other set classes. The doc for the PowerSet would look like ![image](https://user-images.githubusercontent.com/34944973/64371749-50a3ee00-d05c-11e9-93b5-1965085ba1d0.png) #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - sets - Added `PowerSet` for representing symbolic power set. - Fixed table-of-contents in the set documentation. - Added missing documentation about `SymmetricDifference`, `ConditionSet`. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/sets/powerset.py] (definition of PowerSet:) class PowerSet(Set): """A symbolic object representing a power set. Parameters ========== arg : Set The set to take power of. evaluate : bool The flag to control evaluation. If the evaluation is disabled for finite sets, it can take advantage of using subset test as a membership test. Notes ===== Power set `\mathcal{P}(S)` is defined as a set containing all the subsets of `S`. If the set `S` is a finite set, its power set would have `2^{\left\| S \right\|}` elements, where `\left\| S \right\|` denotes the cardinality of `S`. Examples ======== >>> from sympy.sets.powerset import PowerSet >>> from sympy import S, FiniteSet A power set of a finite set: >>> PowerSet(FiniteSet(1, 2, 3)) PowerSet({1, 2, 3}) A power set of an empty set: >>> PowerSet(S.EmptySet) PowerSet(EmptySet()) >>> PowerSet(PowerSet(S.EmptySet)) PowerSet(PowerSet(EmptySet())) A power set of an infinite set: >>> PowerSet(S.Reals) PowerSet(Reals) Evaluating the power set of a finite set to its explicit form: >>> PowerSet(FiniteSet(1, 2, 3)).rewrite(FiniteSet) {EmptySet(), {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}} References ========== .. [1] https://en.wikipedia.org/wiki/Power_set .. [2] https://en.wikipedia.org/wiki/Axiom_of_power_set""" (definition of PowerSet.__new__:) def __new__(cls, arg, evaluate=global_evaluate[0]): (definition of PowerSet.arg:) def arg(self): (definition of PowerSet._eval_rewrite_as_FiniteSet:) def _eval_rewrite_as_FiniteSet(self, args, kwargs): (definition of PowerSet._contains:) def _contains(self, other): (definition of PowerSet._eval_is_subset:) def _eval_is_subset(self, other): (definition of PowerSet.__len__:) def __len__(self): (definition of PowerSet.__iter__:) def __iter__(self): [end of new definitions in sympy/sets/powerset.py] [start of new definitions in sympy/sets/sets.py] (definition of FiniteSet._eval_rewrite_as_PowerSet:) def _eval_rewrite_as_PowerSet(self, args, **kwargs): """Rewriting method for a finite set to a power set.""" [end of new definitions in sympy/sets/sets.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
rytilahti__python-miio-544	544	rytilahti/python-miio	null	7df68214bf2008e7bb30100d93c3f8c61183daf7	2019-09-02T09:03:19Z	diff --git a/README.rst b/README.rst index 74e3888de..2d7270df1 100644 --- a/README.rst +++ b/README.rst @@ -34,6 +34,7 @@ Supported devices - Xiaomi Smartmi Fresh Air System (:class:`miio.airfresh`) - :doc:`Yeelight light bulbs <yeelight>` (:class:`miio.yeelight`) (only a very rudimentary support, use `python-yeelight <https://gitlab.com/stavros/python-yeelight/>`__ for a more complete support) - Xiaomi Mi Air Dehumidifier (:class:`miio.airdehumidifier`) +- Xiaomi Tinymu Smart Toilet Cover (:class:`miio.toiletlid`) - Xiaomi 16 Relays Module (:class:`miio.pwzn_relay`) *Feel free to create a pull request to add support for new devices as diff --git a/miio/__init__.py b/miio/__init__.py index 7941d43cc..d9489f0d1 100644 --- a/miio/__init__.py +++ b/miio/__init__.py @@ -18,6 +18,7 @@ from miio.philips_moonlight import PhilipsMoonlight from miio.powerstrip import PowerStrip from miio.protocol import Message, Utils +from miio.toiletlid import Toiletlid from miio.pwzn_relay import PwznRelay from miio.vacuum import Vacuum, VacuumException from miio.vacuumcontainers import (VacuumStatus, ConsumableStatus, DNDStatus, diff --git a/miio/discovery.py b/miio/discovery.py index 9f9e97e2d..afce254d7 100644 --- a/miio/discovery.py +++ b/miio/discovery.py @@ -10,7 +10,8 @@ from . import (Device, Vacuum, ChuangmiCamera, ChuangmiPlug, PowerStrip, AirPurifier, AirFresh, Ceil, PhilipsBulb, PhilipsEyecare, PhilipsMoonlight, ChuangmiIr, AirHumidifier, WaterPurifier, WifiSpeaker, WifiRepeater, - Yeelight, Fan, Cooker, AirConditioningCompanion, AirQualityMonitor, AqaraCamera) + Yeelight, Fan, Cooker, AirConditioningCompanion, AirQualityMonitor, AqaraCamera, + Toiletlid) from .airconditioningcompanion import (MODEL_ACPARTNER_V1, MODEL_ACPARTNER_V2, MODEL_ACPARTNER_V3, ) from .airqualitymonitor import (MODEL_AIRQUALITYMONITOR_V1, MODEL_AIRQUALITYMONITOR_B1, @@ -23,6 +24,7 @@ from .fan import (MODEL_FAN_V2, MODEL_FAN_V3, MODEL_FAN_SA1, MODEL_FAN_ZA1, MODEL_FAN_ZA3, MODEL_FAN_ZA4, MODEL_FAN_P5, ) from .powerstrip import (MODEL_POWER_STRIP_V1, MODEL_POWER_STRIP_V2, ) +from .toiletlid import (MODEL_TOILETLID_V1, ) _LOGGER = logging.getLogger(__name__) @@ -89,6 +91,7 @@ "zhimi-fan-za3": partial(Fan, model=MODEL_FAN_ZA3), "zhimi-fan-za4": partial(Fan, model=MODEL_FAN_ZA4), "dmaker-fan-p5": partial(Fan, model=MODEL_FAN_P5), + "tinymu-toiletlid-v1": partial(Toiletlid, model=MODEL_TOILETLID_V1), "zhimi-airfresh-va2": AirFresh, "zhimi-airmonitor-v1": partial(AirQualityMonitor, model=MODEL_AIRQUALITYMONITOR_V1), "cgllc-airmonitor-b1": partial(AirQualityMonitor, model=MODEL_AIRQUALITYMONITOR_B1), diff --git a/miio/toiletlid.py b/miio/toiletlid.py new file mode 100644 index 000000000..84b08c66b --- /dev/null +++ b/miio/toiletlid.py @@ -0,0 +1,144 @@ +import enum +import logging +from typing import Any, Dict + +import click + +from .click_common import command, format_output, EnumType +from .device import Device + +_LOGGER = logging.getLogger(__name__) + +MODEL_TOILETLID_V1 = "tinymu.toiletlid.v1" + +AVAILABLE_PROPERTIES_COMMON = ["work_state", "filter_use_flux", "filter_use_time"] + +AVAILABLE_PROPERTIES = {MODEL_TOILETLID_V1: AVAILABLE_PROPERTIES_COMMON} + + +class AmbientLightColor(enum.Enum): + White = "0" + Yellow = "1" + Powder = "2" + Green = "3" + Purple = "4" + Blue = "5" + Orange = "6" + Red = "7" + + +class ToiletlidStatus: + def __init__(self, data: Dict[str, Any]) -> None: + # {"work_state": 1,"filter_use_flux": 100,"filter_use_time": 180, "ambient_light": "Red"} + self.data = data + + @property + def work_state(self) -> int: + """Device state code""" + return self.data["work_state"] + + @property + def is_on(self) -> bool: + return self.work_state != 1 + + @property + def filter_use_percentage(self) -> str: + """Filter percentage of remaining life""" + return "{}%".format(self.data["filter_use_flux"]) + + @property + def filter_remaining_time(self) -> int: + """Filter remaining life days""" + return self.data["filter_use_time"] + + @property + def ambient_light(self) -> str: + """Ambient light color.""" + return self.data["ambient_light"] + + def __repr__(self) -> str: + return ( + "<ToiletlidStatus work=%s, " + "state=%s, " + "ambient_light=%s, " + "filter_use_percentage=%s, " + "filter_remaining_time=%s>" + % ( + self.is_on, + self.work_state, + self.ambient_light, + self.filter_use_percentage, + self.filter_remaining_time, + ) + ) + + +class Toiletlid(Device): + def __init__( + self, + ip: str = None, + token: str = None, + start_id: int = 0, + debug: int = 0, + lazy_discover: bool = True, + model: str = MODEL_TOILETLID_V1, + ) -> None: + super().__init__(ip, token, start_id, debug, lazy_discover) + + if model in AVAILABLE_PROPERTIES: + self.model = model + else: + self.model = MODEL_TOILETLID_V1 + + @command( + default_output=format_output( + "", + "Work: {result.is_on}\n" + "State: {result.work_state}\n" + "Ambient Light: {result.ambient_light}\n" + "Filter remaining: {result.filter_use_percentage}\n" + "Filter remaining time: {result.filter_remaining_time}\n", + ) + ) + def status(self) -> ToiletlidStatus: + """Retrieve properties.""" + properties = AVAILABLE_PROPERTIES[self.model] + values = self.send("get_prop", properties) + properties_count = len(properties) + values_count = len(values) + if properties_count != values_count: + _LOGGER.error( + "Count (%s) of requested properties does not match the " + "count (%s) of received values.", + properties_count, + values_count, + ) + color = self.get_ambient_light() + return ToiletlidStatus(dict(zip(properties, values), ambient_light=color)) + + @command(default_output=format_output("Nozzle clean")) + def nozzle_clean(self): + """Nozzle clean.""" + return self.send("nozzle_clean", ["on"]) + + @command( + click.argument("color", type=EnumType(AmbientLightColor, False)), + default_output=format_output( + "Set the ambient light to {color} color the next time you start it." + ), + ) + def set_ambient_light(self, color: AmbientLightColor): + """Set Ambient light color.""" + return self.send("set_aled_v_of_uid", ["", color.value]) + + @command(default_output=format_output("Get the Ambient light color.")) + def get_ambient_light(self) -> str: + """Get Ambient light color.""" + color = self.send("get_aled_v_of_uid", [""]) + try: + return AmbientLightColor(color[0]).name + except ValueError: + _LOGGER.warning( + "Get ambient light response error, return unknown value: %s.", color[0] + ) + return "Unknown"	diff --git a/miio/tests/test_toiletlid.py b/miio/tests/test_toiletlid.py new file mode 100644 index 000000000..68f3af149 --- /dev/null +++ b/miio/tests/test_toiletlid.py @@ -0,0 +1,94 @@ +from unittest import TestCase + +import pytest + +from miio.toiletlid import ( + Toiletlid, + ToiletlidStatus, + AmbientLightColor, + MODEL_TOILETLID_V1, +) +from .dummies import DummyDevice + +""" +Response instance +>> status + +Work: False +State: 1 +Ambient Light: Yellow +Filter remaining: 100% +Filter remaining time: 180 +""" + + +class DummyToiletlidV1(DummyDevice, Toiletlid): + def __init__(self, args, *kwargs): + self.model = MODEL_TOILETLID_V1 + self.state = { + "is_on": False, + "work_state": 1, + "ambient_light": "Yellow", + "filter_use_flux": "100", + "filter_use_time": "180", + } + + self.return_values = { + "get_prop": self._get_state, + "nozzle_clean": lambda x: self._set_state("work_state", [97]), + "set_aled_v_of_uid": self.set_aled_v_of_uid, + "get_aled_v_of_uid": self.get_aled_v_of_uid, + } + super().__init__(args, kwargs) + + def set_aled_v_of_uid(self, x): + uid, color = x + return self._set_state("ambient_light", [AmbientLightColor(color).name]) + + def get_aled_v_of_uid(self, uid): + color = self._get_state(["ambient_light"]) + if not AmbientLightColor._member_map_.get(color[0]): + raise ValueError(color) + return AmbientLightColor._member_map_.get(color[0]).value + + +@pytest.fixture(scope="class") +def toiletlidv1(request): + request.cls.device = DummyToiletlidV1() + # TODO add ability to test on a real device + + +@pytest.mark.usefixtures("toiletlidv1") +class TestToiletlidV1(TestCase): + def is_on(self): + return self.device.status().is_on + + def state(self): + return self.device.status() + + def test_status(self): + self.device._reset_state() + + assert repr(self.state()) == repr(ToiletlidStatus(self.device.start_state)) + + assert self.is_on() is False + assert self.state().work_state == self.device.start_state["work_state"] + assert self.state().ambient_light == self.device.start_state["ambient_light"] + assert ( + self.state().filter_use_percentage + == "%s%%" % self.device.start_state["filter_use_flux"] + ) + assert ( + self.state().filter_remaining_time + == self.device.start_state["filter_use_time"] + ) + + def test_set_ambient_light(self): + for value, enum in AmbientLightColor._member_map_.items(): + self.device.set_ambient_light(enum) + assert self.device.status().ambient_light == value + + def test_nozzle_clean(self): + self.device.nozzle_clean() + assert self.is_on() is True + self.device._reset_state()	diff --git a/README.rst b/README.rst index 74e3888de..2d7270df1 100644 --- a/README.rst +++ b/README.rst @@ -34,6 +34,7 @@ Supported devices - Xiaomi Smartmi Fresh Air System (:class:`miio.airfresh`) - :doc:`Yeelight light bulbs <yeelight>` (:class:`miio.yeelight`) (only a very rudimentary support, use `python-yeelight <https://gitlab.com/stavros/python-yeelight/>`__ for a more complete support) - Xiaomi Mi Air Dehumidifier (:class:`miio.airdehumidifier`) +- Xiaomi Tinymu Smart Toilet Cover (:class:`miio.toiletlid`) - Xiaomi 16 Relays Module (:class:`miio.pwzn_relay`) *Feel free to create a pull request to add support for new devices as	[ { "components": [ { "doc": "", "lines": [ 19, 27 ], "name": "AmbientLightColor", "signature": "class AmbientLightColor(enum.Enum):", "type": "class" }, { "doc": "", "lines": [ 30, 71 ...	[ "miio/tests/test_toiletlid.py::TestToiletlidV1::test_nozzle_clean", "miio/tests/test_toiletlid.py::TestToiletlidV1::test_set_ambient_light", "miio/tests/test_toiletlid.py::TestToiletlidV1::test_status" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add tinymu smart toiletlid # select toiletlid status Work: False State: 1 Ambient Light: White Filter remaining: 100% Filter remaining time: 180 # set toiletlid ambient light Support color: blue green orange powder purple red white yellow # nozzle clean ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in miio/toiletlid.py] (definition of AmbientLightColor:) class AmbientLightColor(enum.Enum): (definition of ToiletlidStatus:) class ToiletlidStatus: (definition of ToiletlidStatus.__init__:) def __init__(self, data: Dict[str, Any]) -> None: (definition of ToiletlidStatus.work_state:) def work_state(self) -> int: """Device state code""" (definition of ToiletlidStatus.is_on:) def is_on(self) -> bool: (definition of ToiletlidStatus.filter_use_percentage:) def filter_use_percentage(self) -> str: """Filter percentage of remaining life""" (definition of ToiletlidStatus.filter_remaining_time:) def filter_remaining_time(self) -> int: """Filter remaining life days""" (definition of ToiletlidStatus.ambient_light:) def ambient_light(self) -> str: """Ambient light color.""" (definition of ToiletlidStatus.__repr__:) def __repr__(self) -> str: (definition of Toiletlid:) class Toiletlid(Device): (definition of Toiletlid.__init__:) def __init__( self, ip: str = None, token: str = None, start_id: int = 0, debug: int = 0, lazy_discover: bool = True, model: str = MODEL_TOILETLID_V1, ) -> None: (definition of Toiletlid.status:) def status(self) -> ToiletlidStatus: """Retrieve properties.""" (definition of Toiletlid.nozzle_clean:) def nozzle_clean(self): """Nozzle clean.""" (definition of Toiletlid.set_ambient_light:) def set_ambient_light(self, color: AmbientLightColor): """Set Ambient light color.""" (definition of Toiletlid.get_ambient_light:) def get_ambient_light(self) -> str: """Get Ambient light color.""" [end of new definitions in miio/toiletlid.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		62427d2f796e603520acca3b57b29ec3e6489bca
RDFLib__rdflib-931	931	RDFLib/rdflib	null	827eabd437e0a0b4404559b6acacdf696f700593	2019-08-31T14:14:02Z	diff --git a/rdflib/graph.py b/rdflib/graph.py index 80dc02f80..a92f3bc58 100644 --- a/rdflib/graph.py +++ b/rdflib/graph.py @@ -271,6 +271,7 @@ "Dataset", "UnSupportedAggregateOperation", "ReadOnlyGraphAggregate", + "BatchAddGraph", ] @@ -2013,6 +2014,73 @@ def _assertnode(terms): return True +class BatchAddGraph(object): + ''' + Wrapper around graph that turns calls to :meth:`add` (and optionally, :meth:`addN`) + into calls to :meth:`~rdflib.graph.Graph.addN`. + + :Parameters: + + - `graph`: The graph to wrap + - `batch_size`: The maximum number of triples to buffer before passing to + `graph`'s `addN` + - `batch_addn`: If True, then even calls to `addN` will be batched according to + `batch_size` + + :ivar graph: The wrapped graph + :ivar count: The number of triples buffered since initaialization or the last call + to :meth:`reset` + :ivar batch: The current buffer of triples + + ''' + + def __init__(self, graph, batch_size=1000, batch_addn=False): + if not batch_size or batch_size < 2: + raise ValueError("batch_size must be a positive number") + self.graph = graph + self.__graph_tuple = (graph,) + self.__batch_size = batch_size + self.__batch_addn = batch_addn + self.reset() + + def reset(self): + ''' + Manually clear the buffered triples and reset the count to zero + ''' + self.batch = [] + self.count = 0 + + def add(self, triple_or_quad): + ''' + Add a triple to the buffer + + :param triple: The triple to add + ''' + if len(self.batch) >= self.__batch_size: + self.graph.addN(self.batch) + self.batch = [] + self.count += 1 + if len(triple_or_quad) == 3: + self.batch.append(triple_or_quad + self.__graph_tuple) + else: + self.batch.append(triple_or_quad) + + def addN(self, quads): + if self.__batch_addn: + for q in quads: + self.add(q) + else: + self.graph.addN(quads) + + def __enter__(self): + self.reset() + return self + + def __exit__(self, exc): + if exc[0] is None: + self.graph.addN(self.batch) + + def test(): import doctest	diff --git a/test/test_batch_add.py b/test/test_batch_add.py new file mode 100644 index 000000000..1747100ca --- /dev/null +++ b/test/test_batch_add.py @@ -0,0 +1,89 @@ +import unittest +from rdflib.graph import Graph, BatchAddGraph +from rdflib.term import URIRef + + +class TestBatchAddGraph(unittest.TestCase): + def test_batch_size_zero_denied(self): + with self.assertRaises(ValueError): + BatchAddGraph(Graph(), batch_size=0) + + def test_batch_size_none_denied(self): + with self.assertRaises(ValueError): + BatchAddGraph(Graph(), batch_size=None) + + def test_batch_size_one_denied(self): + with self.assertRaises(ValueError): + BatchAddGraph(Graph(), batch_size=1) + + def test_batch_size_negative_denied(self): + with self.assertRaises(ValueError): + BatchAddGraph(Graph(), batch_size=-12) + + def test_exit_submits_partial_batch(self): + trip = (URIRef('a'), URIRef('b'), URIRef('c')) + g = Graph() + with BatchAddGraph(g, batch_size=10) as cut: + cut.add(trip) + self.assertIn(trip, g) + + def test_add_more_than_batch_size(self): + trips = [(URIRef('a'), URIRef('b%d' % i), URIRef('c%d' % i)) + for i in range(12)] + g = Graph() + with BatchAddGraph(g, batch_size=10) as cut: + for trip in trips: + cut.add(trip) + self.assertEqual(12, len(g)) + + def test_add_quad_for_non_conjunctive_empty(self): + ''' + Graph drops quads that don't match our graph. Make sure we do the same + ''' + g = Graph(identifier='http://example.org/g') + badg = Graph(identifier='http://example.org/badness') + with BatchAddGraph(g) as cut: + cut.add((URIRef('a'), URIRef('b'), URIRef('c'), badg)) + self.assertEqual(0, len(g)) + + def test_add_quad_for_non_conjunctive_pass_on_context_matches(self): + g = Graph() + with BatchAddGraph(g) as cut: + cut.add((URIRef('a'), URIRef('b'), URIRef('c'), g)) + self.assertEqual(1, len(g)) + + def test_no_addN_on_exception(self): + ''' + Even if we've added triples so far, it may be that attempting to add the last + batch is the cause of our exception, so we don't want to attempt again + ''' + g = Graph() + trips = [(URIRef('a'), URIRef('b%d' % i), URIRef('c%d' % i)) + for i in range(12)] + + try: + with BatchAddGraph(g, batch_size=10) as cut: + for i, trip in enumerate(trips): + cut.add(trip) + if i == 11: + raise Exception('myexc') + except Exception as e: + if str(e) != 'myexc': + pass + self.assertEqual(10, len(g)) + + def test_addN_batching_addN(self): + class MockGraph(object): + def __init__(self): + self.counts = [] + + def addN(self, quads): + self.counts.append(sum(1 for _ in quads)) + + g = MockGraph() + quads = [(URIRef('a'), URIRef('b%d' % i), URIRef('c%d' % i), g) + for i in range(12)] + + with BatchAddGraph(g, batch_size=10, batch_addn=True) as cut: + cut.addN(quads) + self.assertEqual(g.counts, [10, 2])		[ { "components": [ { "doc": "Wrapper around graph that turns calls to :meth:`add` (and optionally, :meth:`addN`)\ninto calls to :meth:`~rdflib.graph.Graph.addN`.\n\n:Parameters:\n\n - `graph`: The graph to wrap\n - `batch_size`: The maximum number of triples to buffer before passing to\n `grap...	[ "test/test_batch_add.py::TestBatchAddGraph::test_addN_batching_addN", "test/test_batch_add.py::TestBatchAddGraph::test_add_more_than_batch_size", "test/test_batch_add.py::TestBatchAddGraph::test_add_quad_for_non_conjunctive_empty", "test/test_batch_add.py::TestBatchAddGraph::test_add_quad_for_non_conjunctive_...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Adding a wrapper for batching add() calls to a Graph - Should address RDFLib/rdflib#357 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in rdflib/graph.py] (definition of BatchAddGraph:) class BatchAddGraph(object): """Wrapper around graph that turns calls to :meth:`add` (and optionally, :meth:`addN`) into calls to :meth:`~rdflib.graph.Graph.addN`. :Parameters: - `graph`: The graph to wrap - `batch_size`: The maximum number of triples to buffer before passing to `graph`'s `addN` - `batch_addn`: If True, then even calls to `addN` will be batched according to `batch_size` :ivar graph: The wrapped graph :ivar count: The number of triples buffered since initaialization or the last call to :meth:`reset` :ivar batch: The current buffer of triples""" (definition of BatchAddGraph.__init__:) def __init__(self, graph, batch_size=1000, batch_addn=False): (definition of BatchAddGraph.reset:) def reset(self): """Manually clear the buffered triples and reset the count to zero""" (definition of BatchAddGraph.add:) def add(self, triple_or_quad): """Add a triple to the buffer :param triple: The triple to add""" (definition of BatchAddGraph.addN:) def addN(self, quads): (definition of BatchAddGraph.__enter__:) def __enter__(self): (definition of BatchAddGraph.__exit__:) def __exit__(self, *exc): [end of new definitions in rdflib/graph.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		0c11debb5178157baeac27b735e49a757916d2a6
matplotlib__matplotlib-15127	15,127	matplotlib/matplotlib	3.1	5c486d79fdc9d207d32abcdc76f0cb1b74ffaf67	2019-08-26T12:58:27Z	diff --git a/doc/api/next_api_changes/behavior/15127-TAC.rst b/doc/api/next_api_changes/behavior/15127-TAC.rst new file mode 100644 index 000000000000..fd68c0150551 --- /dev/null +++ b/doc/api/next_api_changes/behavior/15127-TAC.rst @@ -0,0 +1,8 @@ +Raise or warn on registering a colormap twice +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +When using `matplotlib.cm.register_cmap` to register a user provided +or third-party colormap it will now raise a `ValueError` if trying to +over-write one of the built in colormaps and warn if trying to over +write a user registered colormap. This may raise for user-registered +colormaps in the future. diff --git a/doc/users/next_whats_new/2019-08_tac.rst b/doc/users/next_whats_new/2019-08_tac.rst new file mode 100644 index 000000000000..3e7e3648b421 --- /dev/null +++ b/doc/users/next_whats_new/2019-08_tac.rst @@ -0,0 +1,6 @@ + +Add ``cm.unregister_cmap`` function +----------------------------------- + +`.cm.unregister_cmap` allows users to remove a colormap that they +have previously registered. diff --git a/lib/matplotlib/cm.py b/lib/matplotlib/cm.py index b8a67550bff3..d4a8b1df5cb2 100644 --- a/lib/matplotlib/cm.py +++ b/lib/matplotlib/cm.py @@ -24,6 +24,7 @@ from matplotlib import _api, colors, cbook from matplotlib._cm import datad from matplotlib._cm_listed import cmaps as cmaps_listed +from matplotlib.cbook import _warn_external LUTSIZE = mpl.rcParams['image.lut'] @@ -95,30 +96,38 @@ def _warn_deprecated(self): locals().update(_cmap_registry) # This is no longer considered public API cmap_d = _DeprecatedCmapDictWrapper(_cmap_registry) - +__builtin_cmaps = tuple(_cmap_registry) # Continue with definitions ... -def register_cmap(name=None, cmap=None, data=None, lut=None): +def register_cmap(name=None, cmap=None, , override_builtin=False): """ Add a colormap to the set recognized by :func:`get_cmap`. - It can be used in two ways:: + Register a new colormap to be accessed by name :: + + LinearSegmentedColormap('swirly', data, lut) + register_cmap(cmap=swirly_cmap) - register_cmap(name='swirly', cmap=swirly_cmap) + Parameters + ---------- + name : str, optional + The name that can be used in :func:`get_cmap` or :rc:`image.cmap` - register_cmap(name='choppy', data=choppydata, lut=128) + If absent, the name will be the :attr:`~matplotlib.colors.Colormap.name` + attribute of the cmap. - In the first case, cmap* must be a :class:`matplotlib.colors.Colormap` - instance. The name is optional; if absent, the name will - be the :attr:`~matplotlib.colors.Colormap.name` attribute of the cmap. + cmap : matplotlib.colors.Colormap + Despite being the second argument and having a default value, this + is a required argument. - The second case is deprecated. Here, the three arguments are passed to - the :class:`~matplotlib.colors.LinearSegmentedColormap` initializer, - and the resulting colormap is registered. Instead of this implicit - colormap creation, create a `.LinearSegmentedColormap` and use the first - case: ``register_cmap(cmap=LinearSegmentedColormap(name, data, lut))``. + override_builtin : bool + + Allow built-in colormaps to be overridden by a user-supplied + colormap. + + Please do not use this unless you are sure you need it. Notes ----- @@ -126,6 +135,7 @@ def register_cmap(name=None, cmap=None, data=None, lut=None): which can currently be modified and inadvertantly change the global colormap state. This behavior is deprecated and in Matplotlib 3.5 the registered colormap will be immutable. + """ cbook._check_isinstance((str, None), name=name) if name is None: @@ -134,23 +144,21 @@ def register_cmap(name=None, cmap=None, data=None, lut=None): except AttributeError as err: raise ValueError("Arguments must include a name or a " "Colormap") from err - if isinstance(cmap, colors.Colormap): - cmap._global = True - _cmap_registry[name] = cmap - return - if lut is not None or data is not None: - cbook.warn_deprecated( - "3.3", - message="Passing raw data via parameters data and lut to " - "register_cmap() is deprecated since %(since)s and will " - "become an error %(removal)s. Instead use: register_cmap(" - "cmap=LinearSegmentedColormap(name, data, lut))") - # For the remainder, let exceptions propagate. - if lut is None: - lut = mpl.rcParams['image.lut'] - cmap = colors.LinearSegmentedColormap(name, data, lut) + if name in _cmap_registry: + if not override_builtin and name in __builtin_cmaps: + msg = f"Trying to re-register the builtin cmap {name!r}." + raise ValueError(msg) + else: + msg = f"Trying to register the cmap {name!r} which already exists." + _warn_external(msg) + + if not isinstance(cmap, colors.Colormap): + raise ValueError("You must pass a Colormap instance. " + f"You passed {cmap} a {type(cmap)} object.") + cmap._global = True _cmap_registry[name] = cmap + return def get_cmap(name=None, lut=None): @@ -187,6 +195,47 @@ def get_cmap(name=None, lut=None): return _cmap_registry[name]._resample(lut) +def unregister_cmap(name): + """ + Remove a colormap recognized by :func:`get_cmap`. + + You may not remove built-in colormaps. + + If the named colormap is not registered, returns with no error, raises + if you try to de-register a default colormap. + + .. warning :: + + Colormap names are currently a shared namespace that may be used + by multiple packages. Use `unregister_cmap` only if you know you + have registered that name before. In particular, do not + unregister just in case to clean the name before registering a + new colormap. + + Parameters + ---------- + name : str + The name of the colormap to be un-registered + + Returns + ------- + ColorMap or None + If the colormap was registered, return it if not return `None` + + Raises + ------ + ValueError + If you try to de-register a default built-in colormap. + + """ + if name not in _cmap_registry: + return + if name in __builtin_cmaps: + raise ValueError(f"cannot unregister {name!r} which is a builtin " + "colormap.") + return _cmap_registry.pop(name) + + class ScalarMappable: """ A mixin class to map scalar data to RGBA. diff --git a/lib/matplotlib/colors.py b/lib/matplotlib/colors.py index 3e8226b0ce25..9500e5234ff1 100644 --- a/lib/matplotlib/colors.py +++ b/lib/matplotlib/colors.py @@ -652,7 +652,7 @@ def get_bad(self): """Get the color for masked values.""" if not self._isinit: self._init() - return self._lut[self._i_bad] + return np.array(self._lut[self._i_bad]) def set_bad(self, color='k', alpha=None): """Set the color for masked values.""" @@ -665,7 +665,7 @@ def get_under(self): """Get the color for low out-of-range values.""" if not self._isinit: self._init() - return self._lut[self._i_under] + return np.array(self._lut[self._i_under]) def set_under(self, color='k', alpha=None): """Set the color for low out-of-range values.""" @@ -678,7 +678,7 @@ def get_over(self): """Get the color for high out-of-range values.""" if not self._isinit: self._init() - return self._lut[self._i_over] + return np.array(self._lut[self._i_over]) def set_over(self, color='k', alpha=None): """Set the color for high out-of-range values."""	diff --git a/lib/matplotlib/tests/test_colors.py b/lib/matplotlib/tests/test_colors.py index d180fb28afa5..8a1a96b47389 100644 --- a/lib/matplotlib/tests/test_colors.py +++ b/lib/matplotlib/tests/test_colors.py @@ -64,14 +64,44 @@ def test_resample(): def test_register_cmap(): - new_cm = copy.copy(plt.cm.viridis) - cm.register_cmap('viridis2', new_cm) - assert plt.get_cmap('viridis2') == new_cm + new_cm = copy.copy(cm.get_cmap("viridis")) + target = "viridis2" + cm.register_cmap(target, new_cm) + assert plt.get_cmap(target) == new_cm with pytest.raises(ValueError, - match='Arguments must include a name or a Colormap'): + match="Arguments must include a name or a Colormap"): cm.register_cmap() + with pytest.warns(UserWarning): + cm.register_cmap(target, new_cm) + + cm.unregister_cmap(target) + with pytest.raises(ValueError, + match=f'{target!r} is not a valid value for name;'): + cm.get_cmap(target) + # test that second time is error free + cm.unregister_cmap(target) + + with pytest.raises(ValueError, match="You must pass a Colormap instance."): + cm.register_cmap('nome', cmap='not a cmap') + + +def test_double_register_builtin_cmap(): + name = "viridis" + match = f"Trying to re-register the builtin cmap {name!r}." + with pytest.raises(ValueError, match=match): + cm.register_cmap(name, cm.get_cmap(name)) + with pytest.warns(UserWarning): + cm.register_cmap(name, cm.get_cmap(name), override_builtin=True) + + +def test_unregister_builtin_cmap(): + name = "viridis" + match = f'cannot unregister {name!r} which is a builtin colormap.' + with pytest.raises(ValueError, match=match): + cm.unregister_cmap(name) + def test_colormap_global_set_warn(): new_cm = plt.get_cmap('viridis') @@ -94,7 +124,8 @@ def test_colormap_global_set_warn(): new_cm.set_under('k') # Re-register the original - plt.register_cmap(cmap=orig_cmap) + with pytest.warns(UserWarning): + plt.register_cmap(cmap=orig_cmap, override_builtin=True) def test_colormap_dict_deprecate(): @@ -1187,6 +1218,16 @@ def test_get_under_over_bad(): assert_array_equal(cmap.get_bad(), cmap(np.nan)) +@pytest.mark.parametrize('kind', ('over', 'under', 'bad')) +def test_non_mutable_get_values(kind): + cmap = copy.copy(plt.get_cmap('viridis')) + init_value = getattr(cmap, f'get_{kind}')() + getattr(cmap, f'set_{kind}')('k') + black_value = getattr(cmap, f'get_{kind}')() + assert np.all(black_value == [0, 0, 0, 1]) + assert not np.all(init_value == black_value) + + def test_colormap_alpha_array(): cmap = plt.get_cmap('viridis') vals = [-1, 0.5, 2] # under, valid, over	diff --git a/doc/api/next_api_changes/behavior/15127-TAC.rst b/doc/api/next_api_changes/behavior/15127-TAC.rst new file mode 100644 index 000000000000..fd68c0150551 --- /dev/null +++ b/doc/api/next_api_changes/behavior/15127-TAC.rst @@ -0,0 +1,8 @@ +Raise or warn on registering a colormap twice +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +When using `matplotlib.cm.register_cmap` to register a user provided +or third-party colormap it will now raise a `ValueError` if trying to +over-write one of the built in colormaps and warn if trying to over +write a user registered colormap. This may raise for user-registered +colormaps in the future. diff --git a/doc/users/next_whats_new/2019-08_tac.rst b/doc/users/next_whats_new/2019-08_tac.rst new file mode 100644 index 000000000000..3e7e3648b421 --- /dev/null +++ b/doc/users/next_whats_new/2019-08_tac.rst @@ -0,0 +1,6 @@ + +Add ``cm.unregister_cmap`` function +----------------------------------- + +`.cm.unregister_cmap` allows users to remove a colormap that they +have previously registered.	[ { "components": [ { "doc": "Remove a colormap recognized by :func:`get_cmap`.\n\nYou may not remove built-in colormaps.\n\nIf the named colormap is not registered, returns with no error, raises\nif you try to de-register a default colormap.\n\n.. warning ::\n\n Colormap names are currently a shar...	[ "lib/matplotlib/tests/test_colors.py::test_register_cmap", "lib/matplotlib/tests/test_colors.py::test_double_register_builtin_cmap", "lib/matplotlib/tests/test_colors.py::test_unregister_builtin_cmap", "lib/matplotlib/tests/test_colors.py::test_colormap_global_set_warn", "lib/matplotlib/tests/test_colors.py...	[ "lib/matplotlib/tests/test_colors.py::test_create_lookup_table[5-result0]", "lib/matplotlib/tests/test_colors.py::test_create_lookup_table[2-result1]", "lib/matplotlib/tests/test_colors.py::test_create_lookup_table[1-result2]", "lib/matplotlib/tests/test_colors.py::test_resample", "lib/matplotlib/tests/test...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> ENH/API: improvements to register_cmap - protect re-defining built in color maps - warn on re-defining user-defined color maps - add de-register function - [x] Has Pytest style unit tests - [x] Code is [Flake 8](http://flake8.pycqa.org/en/latest/) compliant - [x] New features are documented, with examples if plot related - [x] Documentation is sphinx and numpydoc compliant - [x] Added an entry to doc/users/next_whats_new/ if major new feature (follow instructions in README.rst there) - [x] Documented in doc/api/api_changes.rst if API changed in a backward-incompatible way <!-- Thank you so much for your PR! To help us review your contribution, please consider the following points: - A development guide is available at https://matplotlib.org/devdocs/devel/index.html. - Help with git and github is available at https://matplotlib.org/devel/gitwash/development_workflow.html. - Do not create the PR out of master, but out of a separate branch. - The PR title should summarize the changes, for example "Raise ValueError on non-numeric input to set_xlim". Avoid non-descriptive titles such as "Addresses issue #8576". - The summary should provide at least 1-2 sentences describing the pull request in detail (Why is this change required? What problem does it solve?) and link to any relevant issues. - If you are contributing fixes to docstrings, please pay attention to http://matplotlib.org/devel/documenting_mpl.html#formatting. In particular, note the difference between using single backquotes, double backquotes, and asterisks in the markup. We understand that PRs can sometimes be overwhelming, especially as the reviews start coming in. Please let us know if the reviews are unclear or the recommended next step seems overly demanding, if you would like help in addressing a reviewer's comments, or if you have been waiting too long to hear back on your PR. --> ---------- The general idea seems that matplotlib encourages a lot of third party packages to spawn in the wild, each with one or more colormaps, and each registering their colormaps via the `cm` module. Because there is easily some overlap between those to be expected (package 1 has "rocket", "moon" and "silveraqua", package 2 has "rocket" and "desertnight", user needs to import both because they need "silveraqua" and "desertnight"), there should be a solution that allows both packages to be imported without error. Even the warning might be annoying, in case "rocket" from package 1 and "rocket" from package 2 are in fact identical. Perhaps we should just not use string names and instead use normal qualified python names (`mypackage.mycmap`)... --- edit to clarify: If you're going to need an import to trigger the registration, you already have the module imported, so it's just as good to access an attribute from that module; because module names are unique (in a flat namespace), this handles the problem of name collision for us. ... and, per @jklymak's comment below, now you don't even need to have a registration API. As a meta comment, I mess w colormaps all the time and don’t ever bother registering them. But maybe that’s because I’ve never bothered to set up my own startup package. Agree w @ImportanceOfBeingErnest that being able to override colormap names should be allowed. If I want to replace jet with turbo and call it jet, why not? Overall, what is the end-user interface for colormaps? We really could use documentation on this. Are we all supposed to have our own pip installable packages myplottingsettings ? This feeds into the python matplotlibrc question In order to not be misunderstood here: I did not say one should allow for matplotlib's colormaps to be overridden. In fact a protection layer like the one proposed in this PR makes perfect sense. My comment above was about not protecting additional/external colormaps; or at least find a solution for the case that several packages try to register the same colormap under the same name. Flake8: > ./lib/matplotlib/cm.py:30:1: E302 expected 2 blank lines, found 1 Moved to new doc scheme and took @dstansby 's completion of the sentence. Where do we stand on this in light of #16943 and other discussions in the meeting? This is orthogonal to #16943. While #16943 addresses modification of the default colormap objects, this here addresses replacing default colormap objects. This has three approvals - just needs a rebase? I guess all the tests need to pass as well... </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in lib/matplotlib/cm.py] (definition of unregister_cmap:) def unregister_cmap(name): """Remove a colormap recognized by :func:`get_cmap`. You may not remove built-in colormaps. If the named colormap is not registered, returns with no error, raises if you try to de-register a default colormap. .. warning :: Colormap names are currently a shared namespace that may be used by multiple packages. Use `unregister_cmap` only if you know you have registered that name before. In particular, do not unregister just in case to clean the name before registering a new colormap. Parameters ---------- name : str The name of the colormap to be un-registered Returns ------- ColorMap or None If the colormap was registered, return it if not return `None` Raises ------ ValueError If you try to de-register a default built-in colormap.""" [end of new definitions in lib/matplotlib/cm.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c9be5a6985cc919703959902e9a8d795cfde03ad
joke2k__faker-989	989	joke2k/faker	null	46450c265271029b6cf0c5fa3c5c2e0d4508ca27	2019-08-22T18:19:01Z	diff --git a/faker/providers/date_time/__init__.py b/faker/providers/date_time/__init__.py index 39dab8380f..529db17573 100644 --- a/faker/providers/date_time/__init__.py +++ b/faker/providers/date_time/__init__.py @@ -4,7 +4,7 @@ from datetime import MAXYEAR, timedelta from dateutil import relativedelta -from dateutil.tz import tzlocal, tzutc +from dateutil.tz import gettz, tzlocal, tzutc from faker.utils.datetime_safe import date, datetime, real_date, real_datetime @@ -1962,6 +1962,17 @@ def timezone(self): return self.generator.random.choice( self.random_element(self.countries)['timezones']) + def pytimezone(self, args, kwargs): + """ + Generate a random timezone (see `faker.timezone` for any args) + and return as a python object usable as a `tzinfo` to `datetime` + or other fakers. + + :example faker.pytimezone() + :return dateutil.tz.tz.tzfile + """ + return gettz(self.timezone(args, **kwargs)) + def date_of_birth(self, tzinfo=None, minimum_age=0, maximum_age=115): """ Generate a random date of birth represented as a Date object,	diff --git a/tests/providers/test_date_time.py b/tests/providers/test_date_time.py index 30e9cf0949..ad951a5f13 100644 --- a/tests/providers/test_date_time.py +++ b/tests/providers/test_date_time.py @@ -138,6 +138,16 @@ def test_timezone_conversion(self): today_back = datetime.fromtimestamp(timestamp, utc).date() assert today == today_back + def test_pytimezone(self): + import dateutil + pytz = self.fake.pytimezone() + assert isinstance(pytz, dateutil.tz.tz.tzfile) + + def test_pytimezone_usable(self): + pytz = self.fake.pytimezone() + date = datetime(2000, 1, 1, tzinfo=pytz) + assert date.tzinfo == pytz + def test_datetime_safe(self): from faker.utils import datetime_safe # test using example provided in module		[ { "components": [ { "doc": "Generate a random timezone (see `faker.timezone` for any args)\nand return as a python object usable as a `tzinfo` to `datetime`\nor other fakers.\n\n:example faker.pytimezone()\n:return dateutil.tz.tz.tzfile", "lines": [ 1965, 1974 ]...	[ "tests/providers/test_date_time.py::TestDateTime::test_pytimezone", "tests/providers/test_date_time.py::TestDateTime::test_pytimezone_usable" ]	[ "tests/providers/test_date_time.py::TestKoKR::test_day", "tests/providers/test_date_time.py::TestKoKR::test_month", "tests/providers/test_date_time.py::TestDateTime::test_date_between", "tests/providers/test_date_time.py::TestDateTime::test_date_between_dates", "tests/providers/test_date_time.py::TestDateTi...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add pytimezone for tzinfo objects ### What does this changes Adds a python object faker around the existing `timezone` name faker. ### What was wrong It was a bit of a pain (multiple steps) to fake dates with fake tzinfo. ### How this fixes it It removes one of the steps! Fixes #988 NB: I thought about also doing something like `tzinfo=True` (or a new kwarg) as an argument to the other datetime methods, that makes them use `pytimezone` to generate a tzinfo instead of expecting one. That's more work though, so I thought I'd leave it without agreement on the principle. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/date_time/__init__.py] (definition of Provider.pytimezone:) def pytimezone(self, args, *kwargs): """Generate a random timezone (see `faker.timezone` for any args) and return as a python object usable as a `tzinfo` to `datetime` or other fakers. :example faker.pytimezone() :return dateutil.tz.tz.tzfile""" [end of new definitions in faker/providers/date_time/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> suggestion: pytimezone In addition to the currently available [timezone](), it would be very useful* to have a similar python object faker, something like: ```python import pytz class TheExistingPythonProvider: def pytimezone(self, kwargs): return pytz.timezone(self.generator.timezone(kwargs)) ``` For an example use-case, see: \* FactoryBoy/factory_boy#643 ---------- I'm +1 on add a timezone provider. I just wonder if it should go into the `date_time` provider than the `python` one. Either way, feel free to submit a PR and I'll review it :) Oh, true, since date_time provider does already have python `datetime` objects. 👍 Will do. -------------------- </issues>	6edfdbf6ae90b0153309e3bf066aa3b2d16494a7
sympy__sympy-17472	17,472	sympy/sympy	1.5	261c6c3f33955aaa3e13b8c9607dd80bf4021268	2019-08-21T10:18:36Z	diff --git a/sympy/functions/elementary/complexes.py b/sympy/functions/elementary/complexes.py index abfeffa76d1b..b91aa60d7ea5 100644 --- a/sympy/functions/elementary/complexes.py +++ b/sympy/functions/elementary/complexes.py @@ -628,6 +628,9 @@ def _eval_rewrite_as_Piecewise(self, arg, kwargs): def _eval_rewrite_as_sign(self, arg, kwargs): return arg/sign(arg) + def _eval_rewrite_as_conjugate(self, arg, *kwargs): + return (argconjugate(arg))**(S.Half) + class arg(Function): """	diff --git a/sympy/functions/elementary/tests/test_complexes.py b/sympy/functions/elementary/tests/test_complexes.py index 294a01910a66..00876965708f 100644 --- a/sympy/functions/elementary/tests/test_complexes.py +++ b/sympy/functions/elementary/tests/test_complexes.py @@ -478,6 +478,14 @@ def test_Abs_rewrite(): assert abs(i).rewrite(Piecewise) == Piecewise((Ii, Ii >= 0), (-Ii, True)) + assert Abs(y).rewrite(conjugate) == sqrt(yconjugate(y)) + assert Abs(i).rewrite(conjugate) == sqrt(-i*2) # == -Ii + + y = Symbol('y', extended_real=True) + assert (Abs(exp(-Ix)-exp(-Iy))*2).rewrite(conjugate) == \ + -exp(Ix)exp(-Iy) + 2 - exp(-Ix)exp(I*y) + + def test_Abs_real(): # test some properties of abs that only apply # to real numbers		[ { "components": [ { "doc": "", "lines": [ 631, 632 ], "name": "Abs._eval_rewrite_as_conjugate", "signature": "def _eval_rewrite_as_conjugate(self, arg, **kwargs):", "type": "function" } ], "file": "sympy/functions/elementary...	[ "test_Abs_rewrite" ]	[ "test_re", "test_im", "test_sign", "test_as_real_imag", "test_Abs", "test_Abs_real", "test_Abs_properties", "test_abs", "test_arg", "test_arg_rewrite", "test_adjoint", "test_conjugate", "test_conjugate_transpose", "test_transpose", "test_polarify", "test_unpolarify", "test_issue_4035...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Rewrite Abs as conjugate <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed Abs can now be rewritten as conjugate. Motivating example is: ``` (Abs(exp(-Ix)-exp(-Iy))*2).rewrite(conjugate) ``` which gives ``` -exp(Ix)exp(-Iy) + 2 - exp(-Ix)exp(Iy) ``` (with x and y real). Useful for signal processing applications if nothing else. #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> functions * `Abs` can be rewritten as `conjugate`. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/functions/elementary/complexes.py] (definition of Abs._eval_rewrite_as_conjugate:) def _eval_rewrite_as_conjugate(self, arg, **kwargs): [end of new definitions in sympy/functions/elementary/complexes.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-17429	17,429	sympy/sympy	1.5	40da07b3a8ca3b315aaf25ec4ac21dfe4364a097	2019-08-15T22:02:13Z	diff --git a/sympy/functions/elementary/exponential.py b/sympy/functions/elementary/exponential.py index 5a5ee285715b..4cd84f026f7f 100644 --- a/sympy/functions/elementary/exponential.py +++ b/sympy/functions/elementary/exponential.py @@ -491,11 +491,11 @@ def _eval_rewrite_as_Pow(self, arg, *kwargs): return Pow(logs[0].args[0], arg.coeff(logs[0])) -def _match_real_imag(expr): +def match_real_imag(expr): """ Try to match expr with a + bI for real a and b. - ``_match_real_imag`` returns a tuple containing the real and imaginary + ``match_real_imag`` returns a tuple containing the real and imaginary parts of expr or (None, None) if direct matching is not possible. Contrary to ``re()``, ``im()``, ``as_real_imag()``, this helper won't force things by returning expressions themselves containing ``re()`` or ``im()`` and it @@ -607,7 +607,7 @@ def eval(cls, arg, base=None): if isinstance(arg, exp) and arg.args[0].is_extended_real: return arg.args[0] elif isinstance(arg, exp) and arg.args[0].is_number: - r_, i_ = _match_real_imag(arg.args[0]) + r_, i_ = match_real_imag(arg.args[0]) if i_ and i_.is_comparable: i_ %= 2S.Pi if i_ > S.Pi: diff --git a/sympy/functions/elementary/hyperbolic.py b/sympy/functions/elementary/hyperbolic.py index dde790eb5562..f7b18da97b7d 100644 --- a/sympy/functions/elementary/hyperbolic.py +++ b/sympy/functions/elementary/hyperbolic.py @@ -1,11 +1,12 @@ from __future__ import print_function, division -from sympy.core import S, sympify, cacheit +from sympy.core import S, sympify, cacheit, pi, I from sympy.core.add import Add from sympy.core.function import Function, ArgumentIndexError, _coeff_isneg from sympy.functions.combinatorial.factorials import factorial, RisingFactorial -from sympy.functions.elementary.exponential import exp, log +from sympy.functions.elementary.exponential import exp, log, match_real_imag from sympy.functions.elementary.miscellaneous import sqrt +from sympy.functions.elementary.integers import floor def _rewrite_hyperbolics_as_exp(expr): @@ -926,6 +927,20 @@ def eval(cls, arg): if _coeff_isneg(arg): return -cls(-arg) + if isinstance(arg, sinh) and arg.args[0].is_number: + z = arg.args[0] + if z.is_real: + return z + r, i = match_real_imag(z) + if r is not None and i is not None: + f = floor((i + pi/2)/pi) + m = z - Ipif + even = f.is_even + if even is True: + return m + elif even is False: + return -m + @staticmethod @cacheit def taylor_term(n, x, previous_terms): @@ -1033,6 +1048,28 @@ def eval(cls, arg): if arg == -S.ImaginaryUnitS.Infinity: return S.Infinity - S.ImaginaryUnitS.Pi/2 + if isinstance(arg, cosh) and arg.args[0].is_number: + z = arg.args[0] + if z.is_real: + from sympy.functions.elementary.complexes import Abs + return Abs(z) + r, i = match_real_imag(z) + if r is not None and i is not None: + f = floor(i/pi) + m = z - Ipif + even = f.is_even + if even is True: + if r.is_nonnegative: + return m + elif r.is_negative: + return -m + elif even is False: + m -= Ipi + if r.is_nonpositive: + return -m + elif r.is_positive: + return m + @staticmethod @cacheit def taylor_term(n, x, previous_terms): @@ -1121,6 +1158,20 @@ def eval(cls, arg): if _coeff_isneg(arg): return -cls(-arg) + if isinstance(arg, tanh) and arg.args[0].is_number: + z = arg.args[0] + if z.is_real: + return z + r, i = match_real_imag(z) + if r is not None and i is not None: + f = floor(2i/pi) + even = f.is_even + m = z - Ifpi/2 + if even is True: + return m + elif even is False: + return m - Ipi/2 + @staticmethod @cacheit def taylor_term(n, x, *previous_terms):	diff --git a/sympy/core/tests/test_evalf.py b/sympy/core/tests/test_evalf.py index 52aa0a56eb35..63a034768552 100644 --- a/sympy/core/tests/test_evalf.py +++ b/sympy/core/tests/test_evalf.py @@ -1,7 +1,7 @@ from sympy import (Abs, Add, atan, ceiling, cos, E, Eq, exp, factor, factorial, fibonacci, floor, Function, GoldenRatio, I, Integral, integrate, log, Mul, N, oo, pi, Pow, product, Product, - Rational, S, Sum, simplify, sin, sqrt, sstr, sympify, Symbol, Max, nfloat) + Rational, S, Sum, simplify, sin, sqrt, sstr, sympify, Symbol, Max, nfloat, cosh, acosh, acos) from sympy.core.numbers import comp from sympy.core.evalf import (complex_accuracy, PrecisionExhausted, scaled_zero, get_integer_part, as_mpmath, evalf) @@ -567,3 +567,7 @@ def test_issue_13425(): assert N('2*.5', 30) == N('sqrt(2)', 30) assert N('x - x', 30) == 0 assert abs((N('pi.1', 22)10 - pi).n()) < 1e-22 + + +def test_issue_17421(): + assert N(acos(-I + acosh(cosh(cosh(1) + I)))) == 1.0I diff --git a/sympy/functions/elementary/tests/test_exponential.py b/sympy/functions/elementary/tests/test_exponential.py index c7794d845e31..9a18a0988a2f 100644 --- a/sympy/functions/elementary/tests/test_exponential.py +++ b/sympy/functions/elementary/tests/test_exponential.py @@ -3,7 +3,7 @@ LambertW, sqrt, Rational, expand_log, S, sign, conjugate, refine, sin, cos, sinh, cosh, tanh, exp_polar, re, Function, simplify, AccumBounds, MatrixSymbol, Pow, gcd, Sum, Product) -from sympy.functions.elementary.exponential import _match_real_imag +from sympy.functions.elementary.exponential import match_real_imag from sympy.abc import x, y, z from sympy.core.expr import unchanged from sympy.core.function import ArgumentIndexError @@ -221,16 +221,16 @@ def test_log_values(): def test_match_real_imag(): x, y = symbols('x,y', real=True) i = Symbol('i', imaginary=True) - assert _match_real_imag(S.One) == (1, 0) - assert _match_real_imag(I) == (0, 1) - assert _match_real_imag(3 - 5I) == (3, -5) - assert _match_real_imag(-sqrt(3) + S.HalfI) == (-sqrt(3), S.Half) - assert _match_real_imag(x + yI) == (x, y) - assert _match_real_imag(xI + yI) == (0, x + y) - assert _match_real_imag((x + y)I) == (0, x + y) - assert _match_real_imag(-S(2)/3iI) == (None, None) - assert _match_real_imag(1 - 2i) == (None, None) - assert _match_real_imag(sqrt(2)(3 - 5I)) == (None, None) + assert match_real_imag(S.One) == (1, 0) + assert match_real_imag(I) == (0, 1) + assert match_real_imag(3 - 5I) == (3, -5) + assert match_real_imag(-sqrt(3) + S.HalfI) == (-sqrt(3), S.Half) + assert match_real_imag(x + yI) == (x, y) + assert match_real_imag(xI + yI) == (0, x + y) + assert match_real_imag((x + y)I) == (0, x + y) + assert match_real_imag(-S(2)/3iI) == (None, None) + assert match_real_imag(1 - 2i) == (None, None) + assert match_real_imag(sqrt(2)(3 - 5I)) == (None, None) def test_log_exact(): diff --git a/sympy/functions/elementary/tests/test_hyperbolic.py b/sympy/functions/elementary/tests/test_hyperbolic.py index dd21df540d65..237533224ea2 100644 --- a/sympy/functions/elementary/tests/test_hyperbolic.py +++ b/sympy/functions/elementary/tests/test_hyperbolic.py @@ -1,7 +1,7 @@ from sympy import (symbols, Symbol, sinh, nan, oo, zoo, pi, asinh, acosh, log, sqrt, coth, I, cot, E, tanh, tan, cosh, cos, S, sin, Rational, atanh, acoth, Integer, O, exp, sech, sec, csch, asech, acsch, acos, asin, expand_mul, - AccumBounds, im, re) + AccumBounds, im, re, Abs) from sympy.core.expr import unchanged from sympy.core.function import ArgumentIndexError @@ -508,6 +508,20 @@ def test_asinh(): # Symmetry assert asinh(-S.Half) == -asinh(S.Half) + # inverse composition + assert unchanged(asinh, sinh(Symbol('v1'))) + + assert asinh(sinh(0, evaluate=False)) == 0 + assert asinh(sinh(-3, evaluate=False)) == -3 + assert asinh(sinh(2, evaluate=False)) == 2 + assert asinh(sinh(I, evaluate=False)) == I + assert asinh(sinh(-I, evaluate=False)) == -I + assert asinh(sinh(5I, evaluate=False)) == -2Ipi + 5I + assert asinh(sinh(15 + 11I)) == 15 - 4Ipi + 11I + assert asinh(sinh(-73 + 97I)) == 73 - 97I + 31Ipi + assert asinh(sinh(-7 - 23I)) == 7 - 7Ipi + 23I + assert asinh(sinh(13 - 3I)) == -13 - Ipi + 3I + def test_asinh_rewrite(): x = Symbol('x') @@ -570,6 +584,22 @@ def test_acosh(): assert str(acosh(5I).n(6)) == '2.31244 + 1.5708I' assert str(acosh(-5I).n(6)) == '2.31244 - 1.5708I' + # inverse composition + assert unchanged(acosh, Symbol('v1')) + + assert acosh(cosh(-3, evaluate=False)) == 3 + assert acosh(cosh(3, evaluate=False)) == 3 + assert acosh(cosh(0, evaluate=False)) == 0 + assert acosh(cosh(I, evaluate=False)) == I + assert acosh(cosh(-I, evaluate=False)) == I + assert acosh(cosh(7I, evaluate=False)) == -2Ipi + 7I + assert acosh(cosh(1 + I)) == 1 + I + assert acosh(cosh(3 - 3I)) == 3 - 3I + assert acosh(cosh(-3 + 2I)) == 3 - 2I + assert acosh(cosh(-5 - 17I)) == 5 - 6Ipi + 17I + assert acosh(cosh(-21 + 11I)) == 21 - 11I + 4Ipi + assert acosh(cosh(cosh(1) + I)) == cosh(1) + I + def test_acosh_rewrite(): x = Symbol('x') @@ -780,6 +810,24 @@ def test_atanh(): # Symmetry assert atanh(-S.Half) == -atanh(S.Half) + # inverse composition + assert unchanged(atanh, tanh(Symbol('v1'))) + + assert atanh(tanh(-5, evaluate=False)) == -5 + assert atanh(tanh(0, evaluate=False)) == 0 + assert atanh(tanh(7, evaluate=False)) == 7 + assert atanh(tanh(I, evaluate=False)) == I + assert atanh(tanh(-I, evaluate=False)) == -I + assert atanh(tanh(-11I, evaluate=False)) == -11I + 4Ipi + assert atanh(tanh(3 + I)) == 3 + I + assert atanh(tanh(4 + 5I)) == 4 - 2Ipi + 5I + assert atanh(tanh(pi/2)) == pi/2 + assert atanh(tanh(pi)) == pi + assert atanh(tanh(-3 + 7I)) == -3 - 2Ipi + 7I + assert atanh(tanh(9 - 2I/3)) == 9 - 2I/3 + assert atanh(tanh(-32 - 123I)) == -32 - 123I + 39I*pi + + def test_atanh_rewrite(): x = Symbol('x') assert atanh(x).rewrite(log) == (log(1 + x) - log(1 - x)) / 2		[ { "components": [ { "doc": "Try to match expr with a + b*I for real a and b.\n\n``match_real_imag`` returns a tuple containing the real and imaginary\nparts of expr or (None, None) if direct matching is not possible. Contrary\nto ``re()``, ``im()``, ``as_real_imag()``, this helper won't force thin...	[ "test_exp_values", "test_exp_period", "test_exp_log", "test_exp_expand", "test_exp__as_base_exp", "test_exp_infinity", "test_exp_subs", "test_exp_conjugate", "test_exp_rewrite", "test_exp_leading_term", "test_exp_taylor_term", "test_exp_MatrixSymbol", "test_exp_fdiff", "test_log_values", ...	[ "test_evalf_helpers", "test_evalf_basic", "test_cancellation", "test_evalf_powers", "test_evalf_rump", "test_evalf_complex", "test_evalf_complex_powers", "test_evalf_exponentiation", "test_evalf_complex_cancellation", "test_evalf_logs", "test_evalf_trig", "test_evalf_near_integers", "test_ev...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add automatic evaluation for compositions of inverse hyperbolic functions #### References to other Issues or PRs Closes #17421. The more difficult issue with evaluation near branch cuts is not addressed, but there is another issue that covers that (#6137). #### Brief description of what is fixed or changed Add automatic evaluation of `atanh(tanh(x)), acosh(cosh(x)), asinh(sinh(x))` for suitable `x`. #### Release Notes <!-- BEGIN RELEASE NOTES --> * functions * atanh(tanh(x)), acosh(cosh(x)) and asinh(sinh(x)) are automatically evaluated <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/functions/elementary/exponential.py] (definition of match_real_imag:) def match_real_imag(expr): """Try to match expr with a + b*I for real a and b. ``match_real_imag`` returns a tuple containing the real and imaginary parts of expr or (None, None) if direct matching is not possible. Contrary to ``re()``, ``im()``, ``as_real_imag()``, this helper won't force things by returning expressions themselves containing ``re()`` or ``im()`` and it doesn't expand its argument either.""" [end of new definitions in sympy/functions/elementary/exponential.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Incorrect evaluation of acos(-I + acosh(cosh(cosh(1) + I))) `-I + acosh(cosh(cosh(1) + I))` should be equivalent to `cosh(1)`, and this can be confirmed: ``` >>> N(-I + acosh(cosh(cosh(1) + I))) 1.54308063481524 + 0.e-20I >>> N(cosh(1)) 1.54308063481524 ``` Taking `acos`, the sign gets flipped: ``` >>> a = -I + acosh(cosh(cosh(1) + I)) >>> N(acos(a)) 3.60377845017333e-22 - 1.0I >>> N(acos(cosh(1))) 1.0I ``` Trying with explicit evaluation: ``` >>> a = -I + acosh(cosh(cosh(1) + I)) >>> N(acos(a)) 3.60377845017333e-22 - 1.0I >>> N(a) 1.54308063481524 + 0.e-20I >>> acos(_) 1.15320910405546e-20 - 1.0I >>> acos(1.54308063481524 + 0.e-20I) 0.999999999999997I >>> acos(1.54308063481524) 0.999999999999997I ``` ---------- Actually, I think this is more of a mpmath issue- will close unless anyone feels otherwise. What makes you think it is an issue with mpmath rather than sympy? Never mind. I guess the issue is that any positive imaginary part no matter how small is going to cause the sign to flip from `I` to `-I`. perhaps related to #6137? See this [comment](https://github.com/sympy/sympy/issues/6137#issuecomment-37004430). Maybe evalf should have some understanding of branch cuts at least so that it doesn't report excess precision near to them. Or maybe just any way to simplify `acosh(cosh(x))`? As far as I know there's nothing in `trigsimp` (or anywhere) that deals with hyperbolic inverse compositions. Something like this: ``` def acosh_simp(x): # simplify acosh(cosh(x)) if x.is_real: if x.is_nonnegative: return x elif x.is_negative: return -x else: r, i = x.as_real_imag() if r.is_number and i.is_number: n1 = floor(i / pi) if n1 % 2 == 0: m = r + I (i - pin1) if r.is_nonnegative: return m else: return -m else: m = r + I (i - pi*n1 - pi) if r.is_nonpositive: return -m else: return m ``` -------------------- </issues>	c72f122f67553e1af930bac6c35732d2a0bbb776
prometheus__client_python-453	453	prometheus/client_python	null	86018734d50bb385d75a0abf0f62c4bb0d0c24cf	2019-08-13T13:02:19Z	diff --git a/prometheus_client/registry.py b/prometheus_client/registry.py index fa2717fb..7f86a000 100644 --- a/prometheus_client/registry.py +++ b/prometheus_client/registry.py @@ -12,11 +12,13 @@ class CollectorRegistry(object): exposition formats. """ - def __init__(self, auto_describe=False): + def __init__(self, auto_describe=False, target_info=None): self._collector_to_names = {} self._names_to_collectors = {} self._auto_describe = auto_describe self._lock = Lock() + self._target_info = {} + self.set_target_info(target_info) def register(self, collector): """Add a collector to the registry.""" @@ -69,8 +71,13 @@ def _get_names(self, collector): def collect(self): """Yields metrics from the collectors in the registry.""" collectors = None + ti = None with self._lock: collectors = copy.copy(self._collector_to_names) + if self._target_info: + ti = self._target_info_metric() + if ti: + yield ti for collector in collectors: for metric in collector.collect(): yield metric @@ -87,11 +94,14 @@ def restricted_registry(self, names): Experimental.""" names = set(names) collectors = set() + metrics = [] with self._lock: + if 'target_info' in names and self._target_info: + metrics.append(self._target_info_metric()) + names.remove('target_info') for name in names: if name in self._names_to_collectors: collectors.add(self._names_to_collectors[name]) - metrics = [] for collector in collectors: for metric in collector.collect(): samples = [s for s in metric.samples if s[0] in names] @@ -106,6 +116,25 @@ def collect(self): return RestrictedRegistry() + def set_target_info(self, labels): + with self._lock: + if labels: + if not self._target_info and 'target_info' in self._names_to_collectors: + raise ValueError('CollectorRegistry already contains a target_info metric') + self._names_to_collectors['target_info'] = None + elif self._target_info: + self._names_to_collectors.pop('target_info', None) + self._target_info = labels + + def get_target_info(self): + with self._lock: + return self._target_info + + def _target_info_metric(self): + m = Metric('target', 'Target metadata', 'info') + m.add_sample('target_info', self._target_info, 1) + return m + def get_sample_value(self, name, labels=None): """Returns the sample value, or None if not found.	diff --git a/tests/test_core.py b/tests/test_core.py index 9ad947cd..dac5c044 100644 --- a/tests/test_core.py +++ b/tests/test_core.py @@ -664,6 +664,9 @@ def test_duplicate_metrics_raises(self): # The name of the histogram itself isn't taken. Gauge('h', 'help', registry=registry) + Info('i', 'help', registry=registry) + self.assertRaises(ValueError, Gauge, 'i_info', 'help', registry=registry) + def test_unregister_works(self): registry = CollectorRegistry() s = Summary('s', 'help', registry=registry) @@ -696,6 +699,34 @@ def test_restricted_registry(self): m.samples = [Sample('s_sum', {}, 7)] self.assertEquals([m], registry.restricted_registry(['s_sum']).collect()) + def test_target_info_injected(self): + registry = CollectorRegistry(target_info={'foo': 'bar'}) + self.assertEqual(1, registry.get_sample_value('target_info', {'foo': 'bar'})) + + def test_target_info_duplicate_detected(self): + registry = CollectorRegistry(target_info={'foo': 'bar'}) + self.assertRaises(ValueError, Info, 'target', 'help', registry=registry) + + registry.set_target_info({}) + i = Info('target', 'help', registry=registry) + registry.set_target_info({}) + self.assertRaises(ValueError, Info, 'target', 'help', registry=registry) + self.assertRaises(ValueError, registry.set_target_info, {'foo': 'bar'}) + registry.unregister(i) + registry.set_target_info({'foo': 'bar'}) + + def test_target_info_restricted_registry(self): + registry = CollectorRegistry(target_info={'foo': 'bar'}) + Summary('s', 'help', registry=registry).observe(7) + + m = Metric('s', 'help', 'summary') + m.samples = [Sample('s_sum', {}, 7)] + self.assertEquals([m], registry.restricted_registry(['s_sum']).collect()) + + m = Metric('target', 'Target metadata', 'info') + m.samples = [Sample('target_info', {'foo': 'bar'}, 1)] + self.assertEquals([m], registry.restricted_registry(['target_info']).collect()) + if __name__ == '__main__': unittest.main()		[ { "components": [ { "doc": "", "lines": [ 119, 127 ], "name": "CollectorRegistry.set_target_info", "signature": "def set_target_info(self, labels):", "type": "function" }, { "doc": "", "lines": [ 129,...	[ "tests/test_core.py::TestCollectorRegistry::test_target_info_duplicate_detected", "tests/test_core.py::TestCollectorRegistry::test_target_info_injected", "tests/test_core.py::TestCollectorRegistry::test_target_info_restricted_registry" ]	[ "tests/test_core.py::TestCounter::test_block_decorator", "tests/test_core.py::TestCounter::test_count_exceptions_not_observable", "tests/test_core.py::TestCounter::test_function_decorator", "tests/test_core.py::TestCounter::test_increment", "tests/test_core.py::TestCounter::test_negative_increment_raises", ...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add target_info to registries This allows target labels as needed by push-based systems to be provided, in a way that doesn't mess up Prometheus's own top-down pull based approach to SD. @SuperQ @RichiH @robskillington @sumeer Here's roughly what I'm thinking. Needs unittests etc. @beorn7 Your input would be appreciated on the pgw front. https://github.com/OpenObservability/OpenMetrics/issues/63 is the general background. Pgw could continue to do this out of band for grouping labels (potentially with the client library using this as a default), or have this as an option. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in prometheus_client/registry.py] (definition of CollectorRegistry.set_target_info:) def set_target_info(self, labels): (definition of CollectorRegistry.get_target_info:) def get_target_info(self): (definition of CollectorRegistry._target_info_metric:) def _target_info_metric(self): [end of new definitions in prometheus_client/registry.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		09a5ae30602a7a81f6174dae4ba08b93ee7feed2
scikit-learn__scikit-learn-14593	14,593	scikit-learn/scikit-learn	0.22	66b0f5fed84d15b63943571e7b124d02763ef3ca	2019-08-07T20:35:07Z	diff --git a/doc/whats_new/v0.22.rst b/doc/whats_new/v0.22.rst index 2b4b0810b8fc3..3a5290dae81fb 100644 --- a/doc/whats_new/v0.22.rst +++ b/doc/whats_new/v0.22.rst @@ -348,6 +348,11 @@ Changelog - \|Enhancement\| :class:`model_selection.RandomizedSearchCV` now accepts lists of parameter distributions. :pr:`14549` by `Andreas Müller`_. +- \|Efficiency\| Improved performance of multimetric scoring in + :func:`model_selection.cross_validate`, + :class:`model_selection.GridSearchCV`, and + :class:`model_selection.RandomizedSearchCV`. :pr:`14593` by `Thomas Fan`_. + - \|Fix\| Reimplemented :class:`model_selection.StratifiedKFold` to fix an issue where one test set could be `n_classes` larger than another. Test sets should now be near-equally sized. :pr:`14704` by `Joel Nothman`_. diff --git a/sklearn/metrics/scorer.py b/sklearn/metrics/scorer.py index 0214c07a21375..daf8b9e11c09d 100644 --- a/sklearn/metrics/scorer.py +++ b/sklearn/metrics/scorer.py @@ -18,8 +18,9 @@ # Arnaud Joly <arnaud.v.joly@gmail.com> # License: Simplified BSD -from abc import ABCMeta from collections.abc import Iterable +from functools import partial +from collections import Counter import numpy as np @@ -44,7 +45,82 @@ from ..base import is_regressor -class _BaseScorer(metaclass=ABCMeta): +def _cached_call(cache, estimator, method, args, kwargs): + """Call estimator with method and args and kwargs.""" + if cache is None: + return getattr(estimator, method)(args, *kwargs) + + try: + return cache[method] + except KeyError: + result = getattr(estimator, method)(args, kwargs) + cache[method] = result + return result + + +class _MultimetricScorer: + """Callable for multimetric scoring used to avoid repeated calls + to `predict_proba`, `predict`, and `decision_function`. + + `_MultimetricScorer` will return a dictionary of scores corresponding to + the scorers in the dictionary. Note that `_MultimetricScorer` can be + created with a dictionary with one key (i.e. only one actual scorer). + + Parameters + ---------- + scorers : dict + Dictionary mapping names to callable scorers. + """ + def __init__(self, scorers): + self._scorers = scorers + + def __call__(self, estimator, args, kwargs): + """Evaluate predicted target values.""" + scores = {} + cache = {} if self._use_cache(estimator) else None + cached_call = partial(_cached_call, cache) + + for name, scorer in self._scorers.items(): + if isinstance(scorer, _BaseScorer): + score = scorer._score(cached_call, estimator, + args, *kwargs) + else: + score = scorer(estimator, args, *kwargs) + scores[name] = score + return scores + + def _use_cache(self, estimator): + """Return True if using a cache is beneficial. + + Caching may be beneficial when one of these conditions holds: + - `_ProbaScorer` will be called twice. + - `_PredictScorer` will be called twice. + - `_ThresholdScorer` will be called twice. + - `_ThresholdScorer` and `_PredictScorer` are called and + estimator is a regressor. + - `_ThresholdScorer` and `_ProbaScorer` are called and + estimator does not have a `decision_function` attribute. + + """ + if len(self._scorers) == 1: # Only one scorer + return False + + counter = Counter([type(v) for v in self._scorers.values()]) + + if any(counter[known_type] > 1 for known_type in + [_PredictScorer, _ProbaScorer, _ThresholdScorer]): + return True + + if counter[_ThresholdScorer]: + if is_regressor(estimator) and counter[_PredictScorer]: + return True + elif (counter[_ProbaScorer] and + not hasattr(estimator, "decision_function")): + return True + return False + + +class _BaseScorer: def __init__(self, score_func, sign, kwargs): self._kwargs = kwargs self._score_func = score_func @@ -58,17 +134,47 @@ def __repr__(self): "" if self._sign > 0 else ", greater_is_better=False", self._factory_args(), kwargs_string)) + def __call__(self, estimator, X, y_true, sample_weight=None): + """Evaluate predicted target values for X relative to y_true. + + Parameters + ---------- + estimator : object + Trained estimator to use for scoring. Must have a predict_proba + method; the output of that is used to compute the score. + + X : array-like or sparse matrix + Test data that will be fed to estimator.predict. + + y_true : array-like + Gold standard target values for X. + + sample_weight : array-like, optional (default=None) + Sample weights. + + Returns + ------- + score : float + Score function applied to prediction of estimator on X. + """ + return self._score(partial(_cached_call, None), estimator, X, y_true, + sample_weight=sample_weight) + def _factory_args(self): """Return non-default make_scorer arguments for repr.""" return "" class _PredictScorer(_BaseScorer): - def __call__(self, estimator, X, y_true, sample_weight=None): + def _score(self, method_caller, estimator, X, y_true, sample_weight=None): """Evaluate predicted target values for X relative to y_true. Parameters ---------- + method_caller : callable + Returns predictions given an estimator, method name, and other + arguments, potentially caching results. + estimator : object Trained estimator to use for scoring. Must have a predict_proba method; the output of that is used to compute the score. @@ -87,8 +193,7 @@ def __call__(self, estimator, X, y_true, sample_weight=None): score : float Score function applied to prediction of estimator on X. """ - - y_pred = estimator.predict(X) + y_pred = method_caller(estimator, "predict", X) if sample_weight is not None: return self._sign self._score_func(y_true, y_pred, sample_weight=sample_weight, @@ -99,11 +204,15 @@ def __call__(self, estimator, X, y_true, sample_weight=None): class _ProbaScorer(_BaseScorer): - def __call__(self, clf, X, y, sample_weight=None): + def _score(self, method_caller, clf, X, y, sample_weight=None): """Evaluate predicted probabilities for X relative to y_true. Parameters ---------- + method_caller : callable + Returns predictions given an estimator, method name, and other + arguments, potentially caching results. + clf : object Trained classifier to use for scoring. Must have a predict_proba method; the output of that is used to compute the score. @@ -124,7 +233,7 @@ def __call__(self, clf, X, y, sample_weight=None): Score function applied to prediction of estimator on X. """ y_type = type_of_target(y) - y_pred = clf.predict_proba(X) + y_pred = method_caller(clf, "predict_proba", X) if y_type == "binary": if y_pred.shape[1] == 2: y_pred = y_pred[:, 1] @@ -145,11 +254,15 @@ def _factory_args(self): class _ThresholdScorer(_BaseScorer): - def __call__(self, clf, X, y, sample_weight=None): + def _score(self, method_caller, clf, X, y, sample_weight=None): """Evaluate decision function output for X relative to y_true. Parameters ---------- + method_caller : callable + Returns predictions given an estimator, method name, and other + arguments, potentially caching results. + clf : object Trained classifier to use for scoring. Must have either a decision_function method or a predict_proba method; the output of @@ -176,17 +289,17 @@ def __call__(self, clf, X, y, sample_weight=None): raise ValueError("{0} format is not supported".format(y_type)) if is_regressor(clf): - y_pred = clf.predict(X) + y_pred = method_caller(clf, "predict", X) else: try: - y_pred = clf.decision_function(X) + y_pred = method_caller(clf, "decision_function", X) # For multi-output multi-class estimator if isinstance(y_pred, list): y_pred = np.vstack([p for p in y_pred]).T except (NotImplementedError, AttributeError): - y_pred = clf.predict_proba(X) + y_pred = method_caller(clf, "predict_proba", X) if y_type == "binary": if y_pred.shape[1] == 2: diff --git a/sklearn/model_selection/_validation.py b/sklearn/model_selection/_validation.py index 66ed73abf96a9..e9374e23c48ca 100644 --- a/sklearn/model_selection/_validation.py +++ b/sklearn/model_selection/_validation.py @@ -14,6 +14,7 @@ import numbers import time from traceback import format_exception_only +from contextlib import suppress import numpy as np import scipy.sparse as sp @@ -24,7 +25,8 @@ _message_with_time) from ..utils.validation import _is_arraylike, _num_samples from ..utils.metaestimators import _safe_split -from ..metrics.scorer import check_scoring, _check_multimetric_scoring +from ..metrics.scorer import (check_scoring, _check_multimetric_scoring, + _MultimetricScorer) from ..exceptions import FitFailedWarning from ._split import check_cv from ..preprocessing import LabelEncoder @@ -493,8 +495,6 @@ def _fit_and_score(estimator, X, y, scorer, train, test, verbose, X_train, y_train = _safe_split(estimator, X, y, train) X_test, y_test = _safe_split(estimator, X, y, test, train) - is_multimetric = not callable(scorer) - n_scorers = len(scorer.keys()) if is_multimetric else 1 try: if y_train is None: estimator.fit(X_train, *fit_params) @@ -508,12 +508,10 @@ def _fit_and_score(estimator, X, y, scorer, train, test, verbose, if error_score == 'raise': raise elif isinstance(error_score, numbers.Number): - if is_multimetric: - test_scores = dict(zip(scorer.keys(), - [error_score, ] n_scorers)) + if isinstance(scorer, dict): + test_scores = {name: error_score for name in scorer} if return_train_score: - train_scores = dict(zip(scorer.keys(), - [error_score, ] * n_scorers)) + train_scores = test_scores.copy() else: test_scores = error_score if return_train_score: @@ -530,14 +528,12 @@ def _fit_and_score(estimator, X, y, scorer, train, test, verbose, else: fit_time = time.time() - start_time - # _score will return dict if is_multimetric is True - test_scores = _score(estimator, X_test, y_test, scorer, is_multimetric) + test_scores = _score(estimator, X_test, y_test, scorer) score_time = time.time() - start_time - fit_time if return_train_score: - train_scores = _score(estimator, X_train, y_train, scorer, - is_multimetric) + train_scores = _score(estimator, X_train, y_train, scorer) if verbose > 2: - if is_multimetric: + if isinstance(test_scores, dict): for scorer_name in sorted(test_scores): msg += ", %s=" % scorer_name if return_train_score: @@ -567,58 +563,38 @@ def _fit_and_score(estimator, X, y, scorer, train, test, verbose, return ret -def _score(estimator, X_test, y_test, scorer, is_multimetric=False): +def _score(estimator, X_test, y_test, scorer): """Compute the score(s) of an estimator on a given test set. - Will return a single float if is_multimetric is False and a dict of floats, - if is_multimetric is True + Will return a dict of floats if `scorer` is a dict, otherwise a single + float is returned. """ - if is_multimetric: - return _multimetric_score(estimator, X_test, y_test, scorer) + if isinstance(scorer, dict): + # will cache method calls if needed. scorer() returns a dict + scorer = _MultimetricScorer(**scorer) + if y_test is None: + scores = scorer(estimator, X_test) else: - if y_test is None: - score = scorer(estimator, X_test) - else: - score = scorer(estimator, X_test, y_test) - - if hasattr(score, 'item'): - try: - # e.g. unwrap memmapped scalars - score = score.item() - except ValueError: - # non-scalar? - pass - - if not isinstance(score, numbers.Number): - raise ValueError("scoring must return a number, got %s (%s) " - "instead. (scorer=%r)" - % (str(score), type(score), scorer)) - return score - - -def _multimetric_score(estimator, X_test, y_test, scorers): - """Return a dict of score for multimetric scoring""" - scores = {} - - for name, scorer in scorers.items(): - if y_test is None: - score = scorer(estimator, X_test) - else: - score = scorer(estimator, X_test, y_test) - - if hasattr(score, 'item'): - try: + scores = scorer(estimator, X_test, y_test) + + error_msg = ("scoring must return a number, got %s (%s) " + "instead. (scorer=%s)") + if isinstance(scores, dict): + for name, score in scores.items(): + if hasattr(score, 'item'): + with suppress(ValueError): + # e.g. unwrap memmapped scalars + score = score.item() + if not isinstance(score, numbers.Number): + raise ValueError(error_msg % (score, type(score), name)) + scores[name] = score + else: # scalar + if hasattr(scores, 'item'): + with suppress(ValueError): # e.g. unwrap memmapped scalars - score = score.item() - except ValueError: - # non-scalar? - pass - scores[name] = score - - if not isinstance(score, numbers.Number): - raise ValueError("scoring must return a number, got %s (%s) " - "instead. (scorer=%s)" - % (str(score), type(score), name)) + scores = scores.item() + if not isinstance(scores, numbers.Number): + raise ValueError(error_msg % (scores, type(scores), scorer)) return scores	diff --git a/sklearn/metrics/tests/test_score_objects.py b/sklearn/metrics/tests/test_score_objects.py index 120bae5275281..71f3c80c72409 100644 --- a/sklearn/metrics/tests/test_score_objects.py +++ b/sklearn/metrics/tests/test_score_objects.py @@ -3,11 +3,13 @@ import shutil import os import numbers +from unittest.mock import Mock import numpy as np import pytest import joblib +from numpy.testing import assert_allclose from sklearn.utils.testing import assert_almost_equal from sklearn.utils.testing import assert_array_equal from sklearn.utils.testing import ignore_warnings @@ -18,10 +20,11 @@ jaccard_score) from sklearn.metrics import cluster as cluster_module from sklearn.metrics.scorer import (check_scoring, _PredictScorer, - _passthrough_scorer) + _passthrough_scorer, _MultimetricScorer) from sklearn.metrics import accuracy_score from sklearn.metrics.scorer import _check_multimetric_scoring from sklearn.metrics import make_scorer, get_scorer, SCORERS +from sklearn.neighbors import KNeighborsClassifier from sklearn.svm import LinearSVC from sklearn.pipeline import make_pipeline from sklearn.cluster import KMeans @@ -546,3 +549,112 @@ def test_scoring_is_not_metric(): check_scoring(Ridge(), r2_score) with pytest.raises(ValueError, match='make_scorer'): check_scoring(KMeans(), cluster_module.adjusted_rand_score) + + +@pytest.mark.parametrize( + ("scorers,expected_predict_count," + "expected_predict_proba_count,expected_decision_func_count"), + [({'a1': 'accuracy', 'a2': 'accuracy', + 'll1': 'neg_log_loss', 'll2': 'neg_log_loss', + 'ra1': 'roc_auc', 'ra2': 'roc_auc'}, 1, 1, 1), + (['roc_auc', 'accuracy'], 1, 0, 1), + (['neg_log_loss', 'accuracy'], 1, 1, 0)]) +def test_multimetric_scorer_calls_method_once(scorers, expected_predict_count, + expected_predict_proba_count, + expected_decision_func_count): + X, y = np.array([[1], [1], [0], [0], [0]]), np.array([0, 1, 1, 1, 0]) + + mock_est = Mock() + fit_func = Mock(return_value=mock_est) + predict_func = Mock(return_value=y) + + pos_proba = np.random.rand(X.shape[0]) + proba = np.c_[1 - pos_proba, pos_proba] + predict_proba_func = Mock(return_value=proba) + decision_function_func = Mock(return_value=pos_proba) + + mock_est.fit = fit_func + mock_est.predict = predict_func + mock_est.predict_proba = predict_proba_func + mock_est.decision_function = decision_function_func + + scorer_dict, _ = _check_multimetric_scoring(LogisticRegression(), scorers) + multi_scorer = _MultimetricScorer(scorer_dict) + results = multi_scorer(mock_est, X, y) + + assert set(scorers) == set(results) # compare dict keys + + assert predict_func.call_count == expected_predict_count + assert predict_proba_func.call_count == expected_predict_proba_count + assert decision_function_func.call_count == expected_decision_func_count + + +def test_multimetric_scorer_calls_method_once_classifier_no_decision(): + predict_proba_call_cnt = 0 + + class MockKNeighborsClassifier(KNeighborsClassifier): + def predict_proba(self, X): + nonlocal predict_proba_call_cnt + predict_proba_call_cnt += 1 + return super().predict_proba(X) + + X, y = np.array([[1], [1], [0], [0], [0]]), np.array([0, 1, 1, 1, 0]) + + # no decision function + clf = MockKNeighborsClassifier(n_neighbors=1) + clf.fit(X, y) + + scorers = ['roc_auc', 'neg_log_loss'] + scorer_dict, _ = _check_multimetric_scoring(clf, scorers) + scorer = _MultimetricScorer(scorer_dict) + scorer(clf, X, y) + + assert predict_proba_call_cnt == 1 + + +def test_multimetric_scorer_calls_method_once_regressor_threshold(): + predict_called_cnt = 0 + + class MockDecisionTreeRegressor(DecisionTreeRegressor): + def predict(self, X): + nonlocal predict_called_cnt + predict_called_cnt += 1 + return super().predict(X) + + X, y = np.array([[1], [1], [0], [0], [0]]), np.array([0, 1, 1, 1, 0]) + + # no decision function + clf = MockDecisionTreeRegressor() + clf.fit(X, y) + + scorers = {'neg_mse': 'neg_mean_squared_error', 'r2': 'roc_auc'} + scorer_dict, _ = _check_multimetric_scoring(clf, scorers) + scorer = _MultimetricScorer(scorer_dict) + scorer(clf, X, y) + + assert predict_called_cnt == 1 + + +def test_multimetric_scorer_sanity_check(): + # scoring dictionary returned is the same as calling each scorer seperately + scorers = {'a1': 'accuracy', 'a2': 'accuracy', + 'll1': 'neg_log_loss', 'll2': 'neg_log_loss', + 'ra1': 'roc_auc', 'ra2': 'roc_auc'} + + X, y = make_classification(random_state=0) + + clf = DecisionTreeClassifier() + clf.fit(X, y) + + scorer_dict, _ = _check_multimetric_scoring(clf, scorers) + multi_scorer = _MultimetricScorer(scorer_dict) + + result = multi_scorer(clf, X, y) + + seperate_scores = { + name: get_scorer(name)(clf, X, y) + for name in ['accuracy', 'neg_log_loss', 'roc_auc']} + + for key, value in result.items(): + score_name = scorers[key] + assert_allclose(value, seperate_scores[score_name])	diff --git a/doc/whats_new/v0.22.rst b/doc/whats_new/v0.22.rst index 2b4b0810b8fc3..3a5290dae81fb 100644 --- a/doc/whats_new/v0.22.rst +++ b/doc/whats_new/v0.22.rst @@ -348,6 +348,11 @@ Changelog - \|Enhancement\| :class:`model_selection.RandomizedSearchCV` now accepts lists of parameter distributions. :pr:`14549` by `Andreas Müller`_. +- \|Efficiency\| Improved performance of multimetric scoring in + :func:`model_selection.cross_validate`, + :class:`model_selection.GridSearchCV`, and + :class:`model_selection.RandomizedSearchCV`. :pr:`14593` by `Thomas Fan`_. + - \|Fix\| Reimplemented :class:`model_selection.StratifiedKFold` to fix an issue where one test set could be `n_classes` larger than another. Test sets should now be near-equally sized. :pr:`14704` by `Joel Nothman`_.	[ { "components": [ { "doc": "Call estimator with method and args and kwargs.", "lines": [ 48, 58 ], "name": "_cached_call", "signature": "def _cached_call(cache, estimator, method, args, *kwargs):", "type": "function" }, { ...	[ "sklearn/metrics/tests/test_score_objects.py::test_all_scorers_repr", "sklearn/metrics/tests/test_score_objects.py::test_check_scoring_and_check_multimetric_scoring", "sklearn/metrics/tests/test_score_objects.py::test_check_scoring_gridsearchcv", "sklearn/metrics/tests/test_score_objects.py::test_make_scorer"...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG] Adds _MultimetricScorer for Optimized Scoring <!-- Thanks for contributing a pull request! Please ensure you have taken a look at the contribution guidelines: https://github.com/scikit-learn/scikit-learn/blob/master/CONTRIBUTING.md#pull-request-checklist --> #### Reference Issues/PRs <!-- Example: Fixes #1234. See also #3456. Please use keywords (e.g., Fixes) to create link to the issues or pull requests you resolved, so that they will automatically be closed when your pull request is merged. See https://github.com/blog/1506-closing-issues-via-pull-requests --> Fixes https://github.com/scikit-learn/scikit-learn/issues/10802 Alternative to https://github.com/scikit-learn/scikit-learn/pull/10979 #### What does this implement/fix? Explain your changes. 1. This PR creates a `_MultimetricScorer` that subclasses dict which is used to reduce the number of calls to `predict`, `predict_proba`, and `decision_function`. 2. The public interface of objects and functions using `scoring` are unchanged. 3. The cache is only used when it is beneficial to use, as defined in `_MultimetricScorer._use_cache`. 4. Users can not create a `_MultimetricScorer` and pass it into `scoring`. #### Any other comments? I do have plans to support custom callables that return dictionaries from the user. This was not included in this PR to narrow the scope of this PR to `_MultimetricScorer`. <!-- Please be aware that we are a loose team of volunteers so patience is necessary; assistance handling other issues is very welcome. We value all user contributions, no matter how minor they are. If we are slow to review, either the pull request needs some benchmarking, tinkering, convincing, etc. or more likely the reviewers are simply busy. In either case, we ask for your understanding during the review process. For more information, see our FAQ on this topic: http://scikit-learn.org/dev/faq.html#why-is-my-pull-request-not-getting-any-attention. Thanks for contributing! --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/metrics/scorer.py] (definition of _cached_call:) def _cached_call(cache, estimator, method, args, kwargs): """Call estimator with method and args and kwargs.""" (definition of _MultimetricScorer:) class _MultimetricScorer: """Callable for multimetric scoring used to avoid repeated calls to `predict_proba`, `predict`, and `decision_function`. `_MultimetricScorer` will return a dictionary of scores corresponding to the scorers in the dictionary. Note that `_MultimetricScorer` can be created with a dictionary with one key (i.e. only one actual scorer). Parameters ---------- scorers : dict Dictionary mapping names to callable scorers.""" (definition of _MultimetricScorer.__init__:) def __init__(self, scorers): (definition of _MultimetricScorer.__call__:) def __call__(self, estimator, args, **kwargs): """Evaluate predicted target values.""" (definition of _MultimetricScorer._use_cache:) def _use_cache(self, estimator): """Return True if using a cache is beneficial. Caching may be beneficial when one of these conditions holds: - `_ProbaScorer` will be called twice. - `_PredictScorer` will be called twice. - `_ThresholdScorer` will be called twice. - `_ThresholdScorer` and `_PredictScorer` are called and estimator is a regressor. - `_ThresholdScorer` and `_ProbaScorer` are called and estimator does not have a `decision_function` attribute.""" (definition of _BaseScorer.__call__:) def __call__(self, estimator, X, y_true, sample_weight=None): """Evaluate predicted target values for X relative to y_true. Parameters ---------- estimator : object Trained estimator to use for scoring. Must have a predict_proba method; the output of that is used to compute the score. X : array-like or sparse matrix Test data that will be fed to estimator.predict. y_true : array-like Gold standard target values for X. sample_weight : array-like, optional (default=None) Sample weights. Returns ------- score : float Score function applied to prediction of estimator on X.""" (definition of _PredictScorer._score:) def _score(self, method_caller, estimator, X, y_true, sample_weight=None): """Evaluate predicted target values for X relative to y_true. Parameters ---------- method_caller : callable Returns predictions given an estimator, method name, and other arguments, potentially caching results. estimator : object Trained estimator to use for scoring. Must have a predict_proba method; the output of that is used to compute the score. X : array-like or sparse matrix Test data that will be fed to estimator.predict. y_true : array-like Gold standard target values for X. sample_weight : array-like, optional (default=None) Sample weights. Returns ------- score : float Score function applied to prediction of estimator on X.""" (definition of _ProbaScorer._score:) def _score(self, method_caller, clf, X, y, sample_weight=None): """Evaluate predicted probabilities for X relative to y_true. Parameters ---------- method_caller : callable Returns predictions given an estimator, method name, and other arguments, potentially caching results. clf : object Trained classifier to use for scoring. Must have a predict_proba method; the output of that is used to compute the score. X : array-like or sparse matrix Test data that will be fed to clf.predict_proba. y : array-like Gold standard target values for X. These must be class labels, not probabilities. sample_weight : array-like, optional (default=None) Sample weights. Returns ------- score : float Score function applied to prediction of estimator on X.""" (definition of _ThresholdScorer._score:) def _score(self, method_caller, clf, X, y, sample_weight=None): """Evaluate decision function output for X relative to y_true. Parameters ---------- method_caller : callable Returns predictions given an estimator, method name, and other arguments, potentially caching results. clf : object Trained classifier to use for scoring. Must have either a decision_function method or a predict_proba method; the output of that is used to compute the score. X : array-like or sparse matrix Test data that will be fed to clf.decision_function or clf.predict_proba. y : array-like Gold standard target values for X. These must be class labels, not decision function values. sample_weight : array-like, optional (default=None) Sample weights. Returns ------- score : float Score function applied to prediction of estimator on X.""" [end of new definitions in sklearn/metrics/scorer.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c96e0958da46ebef482a4084cdda3285d5f5ad23
sympy__sympy-17308	17,308	sympy/sympy	1.5	1e211112f489713902a67c6f03339f44ebc24326	2019-07-31T18:36:02Z	diff --git a/sympy/tensor/array/arrayop.py b/sympy/tensor/array/arrayop.py index 1d22255a35c0..273897b5f4bc 100644 --- a/sympy/tensor/array/arrayop.py +++ b/sympy/tensor/array/arrayop.py @@ -1,10 +1,13 @@ import itertools -from sympy import S, Tuple, diff +from sympy import S, Tuple, diff, Basic from sympy.core.compatibility import Iterable from sympy.tensor.array import ImmutableDenseNDimArray from sympy.tensor.array.ndim_array import NDimArray +from sympy.tensor.array.dense_ndim_array import DenseNDimArray +from sympy.tensor.array.sparse_ndim_array import SparseNDimArray + def _arrayfy(a): from sympy.matrices import MatrixBase @@ -62,10 +65,7 @@ def tensorproduct(args): new_array = {k1lp + k2: v1v2 for k1, v1 in a._sparse_array.items() for k2, v2 in b._sparse_array.items()} return ImmutableSparseNDimArray(new_array, a.shape + b.shape) - al = list(a) - bl = list(b) - - product_list = [ij for i in al for j in bl] + product_list = [ij for i in Flatten(a) for j in Flatten(b)] return ImmutableDenseNDimArray(product_list, a.shape + b.shape) @@ -215,16 +215,16 @@ def derive_by_array(expr, dx): if isinstance(expr, SparseNDimArray): lp = len(expr) new_array = {k + ilp: v - for i, x in enumerate(dx) + for i, x in enumerate(Flatten(dx)) for k, v in expr.diff(x)._sparse_array.items()} else: - new_array = [[y.diff(x) for y in expr] for x in dx] + new_array = [[y.diff(x) for y in Flatten(expr)] for x in Flatten(dx)] return type(expr)(new_array, dx.shape + expr.shape) else: return expr.diff(dx) else: if isinstance(dx, array_types): - return ImmutableDenseNDimArray([expr.diff(i) for i in dx], dx.shape) + return ImmutableDenseNDimArray([expr.diff(i) for i in Flatten(dx)], dx.shape) else: return diff(expr, dx) @@ -296,3 +296,73 @@ def permutedims(expr, perm): new_array[i] = expr[t] return type(expr)(new_array, new_shape) + + +class Flatten(Basic): + ''' + Flatten an iterable object to a list in a lazy-evaluation way. + + Notes + ===== + + This class is an iterator with which the memory cost can be economised. + Optimisation has been considered to ameliorate the performance for some + specific data types like DenseNDimArray and SparseNDimArray. + + Examples + ======== + + >>> from sympy.tensor.array.arrayop import Flatten + >>> from sympy.tensor.array import Array + >>> A = Array(range(6)).reshape(2, 3) + >>> Flatten(A) + Flatten([[0, 1, 2], [3, 4, 5]]) + >>> [i for i in Flatten(A)] + [0, 1, 2, 3, 4, 5] + ''' + def __init__(self, iterable): + from sympy.matrices.matrices import MatrixBase + from sympy.tensor.array import NDimArray + + if not isinstance(iterable, (Iterable, MatrixBase)): + raise NotImplementedError("Data type not yet supported") + + if isinstance(iterable, list): + iterable = NDimArray(iterable) + + self._iter = iterable + self._idx = 0 + + def __iter__(self): + return self + + def __next__(self): + from sympy.matrices.matrices import MatrixBase + + if len(self._iter) > self._idx: + if isinstance(self._iter, DenseNDimArray): + result = self._iter._array[self._idx] + + elif isinstance(self._iter, SparseNDimArray): + if self._idx in self._iter._sparse_array: + result = self._iter._sparse_array[self._idx] + else: + result = 0 + + elif isinstance(self._iter, MatrixBase): + result = self._iter[self._idx] + + elif hasattr(self._iter, '__next__'): + result = next(self._iter) + + else: + result = self._iter[self._idx] + + else: + raise StopIteration + + self._idx += 1 + return result + + def next(self): + return self.__next__() diff --git a/sympy/tensor/array/dense_ndim_array.py b/sympy/tensor/array/dense_ndim_array.py index ccae6f8b4a77..3cb7be896c75 100644 --- a/sympy/tensor/array/dense_ndim_array.py +++ b/sympy/tensor/array/dense_ndim_array.py @@ -52,9 +52,10 @@ def __getitem__(self, index): if syindex is not None: return syindex - if isinstance(index, (SYMPY_INTS, Integer)): + if isinstance(index, (SYMPY_INTS, Integer, slice)): index = (index, ) - if not isinstance(index, slice) and len(index) < self.rank(): + + if len(index) < self.rank(): index = tuple([i for i in index] + \ [slice(None) for i in range(len(index), self.rank())]) @@ -64,11 +65,8 @@ def __getitem__(self, index): nshape = [len(el) for i, el in enumerate(sl_factors) if isinstance(index[i], slice)] return type(self)(array, nshape) else: - if isinstance(index, slice): - return self._array[index] - else: - index = self._parse_index(index) - return self._array[index] + index = self._parse_index(index) + return self._array[index] @classmethod def zeros(cls, shape): @@ -99,12 +97,6 @@ def tomatrix(self): return Matrix(self.shape[0], self.shape[1], self._array) - def __iter__(self): - def iterator(): - for i in range(self._loop_size): - yield self[self._get_tuple_index(i)] - return iterator() - def reshape(self, newshape): """ Returns MutableDenseNDimArray instance with new shape. Elements number diff --git a/sympy/tensor/array/ndim_array.py b/sympy/tensor/array/ndim_array.py index 38010407de9c..379270089f30 100644 --- a/sympy/tensor/array/ndim_array.py +++ b/sympy/tensor/array/ndim_array.py @@ -140,10 +140,7 @@ def _handle_ndarray_creation_inputs(cls, iterable=None, shape=None, *kwargs): # Construction of a sparse array from a sparse array elif isinstance(iterable, SparseNDimArray): return iterable._shape, iterable._sparse_array - # Construction from another `NDimArray`: - elif isinstance(iterable, NDimArray): - shape = iterable.shape - iterable = list(iterable) + # Construct N-dim array from an iterable (numpy arrays included): elif isinstance(iterable, Iterable): iterable, shape = cls._scan_iterable_shape(iterable) @@ -286,11 +283,12 @@ def applyfunc(self, f): [[0, 2], [4, 6]] """ from sympy.tensor.array import SparseNDimArray + from sympy.tensor.array.arrayop import Flatten if isinstance(self, SparseNDimArray) and f(S.Zero) == 0: return type(self)({k: f(v) for k, v in self._sparse_array.items() if f(v) != 0}, self.shape) - return type(self)(map(f, self), self.shape) + return type(self)(map(f, Flatten(self)), self.shape) def __str__(self): """Returns string, allows to use standard functions print() and str(). @@ -366,28 +364,33 @@ def f(sh, shape_left, i, j): return f(self._loop_size, self.shape, 0, self._loop_size) def __add__(self, other): + from sympy.tensor.array.arrayop import Flatten + if not isinstance(other, NDimArray): raise TypeError(str(other)) if self.shape != other.shape: raise ValueError("array shape mismatch") - result_list = [i+j for i,j in zip(self, other)] + result_list = [i+j for i,j in zip(Flatten(self), Flatten(other))] return type(self)(result_list, self.shape) def __sub__(self, other): + from sympy.tensor.array.arrayop import Flatten + if not isinstance(other, NDimArray): raise TypeError(str(other)) if self.shape != other.shape: raise ValueError("array shape mismatch") - result_list = [i-j for i,j in zip(self, other)] + result_list = [i-j for i,j in zip(Flatten(self), Flatten(other))] return type(self)(result_list, self.shape) def __mul__(self, other): from sympy.matrices.matrices import MatrixBase from sympy.tensor.array import SparseNDimArray + from sympy.tensor.array.arrayop import Flatten if isinstance(other, (Iterable, NDimArray, MatrixBase)): raise ValueError("scalar expected, use tensorproduct(...) for tensorial product") @@ -398,12 +401,13 @@ def __mul__(self, other): return type(self)({}, self.shape) return type(self)({k: otherv for (k, v) in self._sparse_array.items()}, self.shape) - result_list = [iother for i in self] + result_list = [iother for i in Flatten(self)] return type(self)(result_list, self.shape) def __rmul__(self, other): from sympy.matrices.matrices import MatrixBase from sympy.tensor.array import SparseNDimArray + from sympy.tensor.array.arrayop import Flatten if isinstance(other, (Iterable, NDimArray, MatrixBase)): raise ValueError("scalar expected, use tensorproduct(...) for tensorial product") @@ -414,12 +418,13 @@ def __rmul__(self, other): return type(self)({}, self.shape) return type(self)({k: otherv for (k, v) in self._sparse_array.items()}, self.shape) - result_list = [otheri for i in self] + result_list = [otheri for i in Flatten(self)] return type(self)(result_list, self.shape) def __div__(self, other): from sympy.matrices.matrices import MatrixBase from sympy.tensor.array import SparseNDimArray + from sympy.tensor.array.arrayop import Flatten if isinstance(other, (Iterable, NDimArray, MatrixBase)): raise ValueError("scalar expected") @@ -428,7 +433,7 @@ def __div__(self, other): if isinstance(self, SparseNDimArray) and other != S.Zero: return type(self)({k: v/other for (k, v) in self._sparse_array.items()}, self.shape) - result_list = [i/other for i in self] + result_list = [i/other for i in Flatten(self)] return type(self)(result_list, self.shape) def __rdiv__(self, other): @@ -436,13 +441,24 @@ def __rdiv__(self, other): def __neg__(self): from sympy.tensor.array import SparseNDimArray + from sympy.tensor.array.arrayop import Flatten if isinstance(self, SparseNDimArray): return type(self)({k: -v for (k, v) in self._sparse_array.items()}, self.shape) - result_list = [-i for i in self] + result_list = [-i for i in Flatten(self)] return type(self)(result_list, self.shape) + def __iter__(self): + def iterator(): + if self._shape: + for i in range(self._shape[0]): + yield self[i] + else: + yield self[()] + + return iterator() + def __eq__(self, other): """ NDimArray instances can be compared to each other. @@ -492,7 +508,9 @@ def transpose(self): return self._eval_transpose() def _eval_conjugate(self): - return self.func([i.conjugate() for i in self], self.shape) + from sympy.tensor.array.arrayop import Flatten + + return self.func([i.conjugate() for i in Flatten(self)], self.shape) def conjugate(self): return self._eval_conjugate() diff --git a/sympy/tensor/array/sparse_ndim_array.py b/sympy/tensor/array/sparse_ndim_array.py index 4084668f219e..6c0124fb739a 100644 --- a/sympy/tensor/array/sparse_ndim_array.py +++ b/sympy/tensor/array/sparse_ndim_array.py @@ -50,9 +50,10 @@ def __getitem__(self, index): if syindex is not None: return syindex - if isinstance(index, (SYMPY_INTS, Integer)): + if isinstance(index, (SYMPY_INTS, Integer, slice)): index = (index, ) - if not isinstance(index, slice) and len(index) < self.rank(): + + if len(index) < self.rank(): index = tuple([i for i in index] + \ [slice(None) for i in range(len(index), self.rank())]) @@ -63,15 +64,8 @@ def __getitem__(self, index): nshape = [len(el) for i, el in enumerate(sl_factors) if isinstance(index[i], slice)] return type(self)(array, nshape) else: - # `index` is a single slice: - if isinstance(index, slice): - start, stop, step = index.indices(self._loop_size) - retvec = [self._sparse_array.get(ind, S.Zero) for ind in range(start, stop, step)] - return retvec - # `index` is a number or a tuple without any slice: - else: - index = self._parse_index(index) - return self._sparse_array.get(index, S.Zero) + index = self._parse_index(index) + return self._sparse_array.get(index, S.Zero) @classmethod def zeros(cls, shape): @@ -106,12 +100,6 @@ def tomatrix(self): return SparseMatrix(self.shape[0], self.shape[1], mat_sparse) - def __iter__(self): - def iterator(): - for i in range(self._loop_size): - yield self[self._get_tuple_index(i)] - return iterator() - def reshape(self, newshape): new_total_size = functools.reduce(lambda x,y: xy, newshape) if new_total_size != self._loop_size: diff --git a/sympy/tensor/tensor.py b/sympy/tensor/tensor.py index 555d50b6f1a8..2a222f245e7e 100644 --- a/sympy/tensor/tensor.py +++ b/sympy/tensor/tensor.py @@ -524,6 +524,7 @@ def _assign_data_to_tensor_expr(self, key, data): def _check_permutations_on_data(self, tens, data): from .array import permutedims + from .array.arrayop import Flatten if isinstance(tens, TensorHead): rank = tens.rank @@ -548,7 +549,7 @@ def _check_permutations_on_data(self, tens, data): for i in range(gener.order()-1): data_swapped = permutedims(data_swapped, permute_axes) # if any value in the difference array is non-zero, raise an error: - if any(last_data - sign_changedata_swapped): + if any(Flatten(last_data - sign_changedata_swapped)): raise ValueError("Component data symmetry structure error") last_data = data_swapped diff --git a/sympy/utilities/iterables.py b/sympy/utilities/iterables.py index 9ff2f61d2de7..d94a872eb8a9 100644 --- a/sympy/utilities/iterables.py +++ b/sympy/utilities/iterables.py @@ -55,6 +55,7 @@ def flatten(iterable, levels=None, cls=None): adapted from https://kogs-www.informatik.uni-hamburg.de/~meine/python_tricks """ + from sympy.tensor.array import NDimArray if levels is not None: if not levels: return iterable @@ -73,7 +74,7 @@ def flatten(iterable, levels=None, cls=None): for el in iterable: if reducible(el): - if hasattr(el, 'args'): + if hasattr(el, 'args') and not isinstance(el, NDimArray): el = el.args result.extend(flatten(el, levels=levels, cls=cls)) else:	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 20b421f5fd7c..9a7c0eda4a42 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -3982,6 +3982,12 @@ def test_sympy__tensor__array__array_comprehension__ArrayComprehension(): arrcom = ArrayComprehension(x, (x, 1, 5)) assert _test_args(arrcom) +def test_sympy__tensor__array__arrayop__Flatten(): + from sympy.tensor.array.arrayop import Flatten + from sympy.tensor.array.dense_ndim_array import ImmutableDenseNDimArray + fla = Flatten(ImmutableDenseNDimArray(range(24)).reshape(2, 3, 4)) + assert _test_args(fla) + def test_sympy__tensor__functions__TensorProduct(): from sympy.tensor.functions import TensorProduct diff --git a/sympy/tensor/array/tests/test_arrayop.py b/sympy/tensor/array/tests/test_arrayop.py index a6510aca87d5..f42cdd3d44cd 100644 --- a/sympy/tensor/array/tests/test_arrayop.py +++ b/sympy/tensor/array/tests/test_arrayop.py @@ -7,7 +7,7 @@ from sympy import symbols, sin, exp, log, cos, transpose, adjoint, conjugate, diff from sympy.tensor.array import Array, ImmutableDenseNDimArray, ImmutableSparseNDimArray, MutableSparseNDimArray -from sympy.tensor.array import tensorproduct, tensorcontraction, derive_by_array, permutedims +from sympy.tensor.array.arrayop import tensorproduct, tensorcontraction, derive_by_array, permutedims, Flatten # Test import although not used in file from sympy.tensor.array import NDimArray @@ -285,3 +285,12 @@ def test_array_permutedims(): assert permutedims(A, (1, 0, 2)) == SparseArrayType({1: 1, 100000000: 2}, (20000, 10000, 10000)) B = SparseArrayType({1:1, 20000:2}, (10000, 20000)) assert B.transpose() == SparseArrayType({10000: 1, 1: 2}, (20000, 10000)) + +def test_flatten(): + from sympy import Matrix + for ArrayType in [ImmutableDenseNDimArray, ImmutableSparseNDimArray, Matrix]: + A = ArrayType(range(24)).reshape(4, 6) + assert [i for i in Flatten(A)] == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23] + + for i, v in enumerate(Flatten(A)): + i == v diff --git a/sympy/tensor/array/tests/test_immutable_ndim_array.py b/sympy/tensor/array/tests/test_immutable_ndim_array.py index 7b7bb402c84d..e4001e98508d 100644 --- a/sympy/tensor/array/tests/test_immutable_ndim_array.py +++ b/sympy/tensor/array/tests/test_immutable_ndim_array.py @@ -24,13 +24,13 @@ def test_ndim_array_initiation(): arr_with_one_element = ImmutableDenseNDimArray([23]) assert len(arr_with_one_element) == 1 assert arr_with_one_element[0] == 23 - assert arr_with_one_element[:] == [23] + assert arr_with_one_element[:] == ImmutableDenseNDimArray([23]) assert arr_with_one_element.rank() == 1 arr_with_symbol_element = ImmutableDenseNDimArray([Symbol('x')]) assert len(arr_with_symbol_element) == 1 assert arr_with_symbol_element[0] == Symbol('x') - assert arr_with_symbol_element[:] == [Symbol('x')] + assert arr_with_symbol_element[:] == ImmutableDenseNDimArray([Symbol('x')]) assert arr_with_symbol_element.rank() == 1 number5 = 5 @@ -123,10 +123,8 @@ def test_getitem(): def test_iterator(): array = ImmutableDenseNDimArray(range(4), (2, 2)) - j = 0 - for i in array: - assert i == j - j += 1 + array[0] == ImmutableDenseNDimArray([0, 1]) + array[1] == ImmutableDenseNDimArray([2, 3]) array = array.reshape(4) j = 0 @@ -141,10 +139,10 @@ def test_sparse(): # dictionary where all data is, only non-zero entries are actually stored: assert len(sparse_array._sparse_array) == 1 - assert list(sparse_array) == [0, 0, 0, 1] + assert sparse_array.tolist() == [[0, 0], [0, 1]] - for i, j in zip(sparse_array, [0, 0, 0, 1]): - assert i == j + for i, j in zip(sparse_array, [[0, 0], [0, 1]]): + assert i == ImmutableSparseNDimArray(j) def sparse_assignment(): sparse_array[0, 0] = 123 @@ -180,14 +178,14 @@ def test_calculation(): c = a + b for i in c: - assert i == 10 + assert i == ImmutableDenseNDimArray([10, 10, 10]) assert c == ImmutableDenseNDimArray([10]9, (3, 3)) assert c == ImmutableSparseNDimArray([10]9, (3, 3)) c = b - a for i in c: - assert i == 8 + assert i == ImmutableDenseNDimArray([8, 8, 8]) assert c == ImmutableDenseNDimArray([8]9, (3, 3)) assert c == ImmutableSparseNDimArray([8]9, (3, 3)) @@ -333,7 +331,7 @@ def test_rebuild_immutable_arrays(): def test_slices(): md = ImmutableDenseNDimArray(range(10, 34), (2, 3, 4)) - assert md[:] == md._array + assert md[:] == ImmutableDenseNDimArray(range(10, 34), (2, 3, 4)) assert md[:, :, 0].tomatrix() == Matrix([[10, 14, 18], [22, 26, 30]]) assert md[0, 1:2, :].tomatrix() == Matrix([[14, 15, 16, 17]]) assert md[0, 1:3, :].tomatrix() == Matrix([[14, 15, 16, 17], [18, 19, 20, 21]]) @@ -342,8 +340,7 @@ def test_slices(): sd = ImmutableSparseNDimArray(range(10, 34), (2, 3, 4)) assert sd == ImmutableSparseNDimArray(md) - assert sd[:] == md._array - assert sd[:] == list(sd) + assert sd[:] == ImmutableSparseNDimArray(range(10, 34), (2, 3, 4)) assert sd[:, :, 0].tomatrix() == Matrix([[10, 14, 18], [22, 26, 30]]) assert sd[0, 1:2, :].tomatrix() == Matrix([[14, 15, 16, 17]]) assert sd[0, 1:3, :].tomatrix() == Matrix([[14, 15, 16, 17], [18, 19, 20, 21]]) diff --git a/sympy/tensor/array/tests/test_mutable_ndim_array.py b/sympy/tensor/array/tests/test_mutable_ndim_array.py index 528b97cf83c0..3f652f0acb6f 100644 --- a/sympy/tensor/array/tests/test_mutable_ndim_array.py +++ b/sympy/tensor/array/tests/test_mutable_ndim_array.py @@ -104,10 +104,8 @@ def test_reshape(): def test_iterator(): array = MutableDenseNDimArray(range(4), (2, 2)) - j = 0 - for i in array: - assert i == j - j += 1 + array[0] == MutableDenseNDimArray([0, 1]) + array[1] == MutableDenseNDimArray([2, 3]) array = array.reshape(4) j = 0 @@ -139,10 +137,10 @@ def test_sparse(): # dictionary where all data is, only non-zero entries are actually stored: assert len(sparse_array._sparse_array) == 1 - assert list(sparse_array) == [0, 0, 0, 1] + assert sparse_array.tolist() == [[0, 0], [0, 1]] - for i, j in zip(sparse_array, [0, 0, 0, 1]): - assert i == j + for i, j in zip(sparse_array, [[0, 0], [0, 1]]): + assert i == MutableSparseNDimArray(j) sparse_array[0, 0] = 123 assert len(sparse_array._sparse_array) == 2 @@ -186,14 +184,14 @@ def test_calculation(): c = a + b for i in c: - assert i == 10 + assert i == MutableDenseNDimArray([10, 10, 10]) assert c == MutableDenseNDimArray([10]9, (3, 3)) assert c == MutableSparseNDimArray([10]9, (3, 3)) c = b - a for i in c: - assert i == 8 + assert i == MutableSparseNDimArray([8, 8, 8]) assert c == MutableDenseNDimArray([8]9, (3, 3)) assert c == MutableSparseNDimArray([8]9, (3, 3)) @@ -329,7 +327,7 @@ def test_higher_dimenions(): def test_slices(): md = MutableDenseNDimArray(range(10, 34), (2, 3, 4)) - assert md[:] == md._array + assert md[:] == MutableDenseNDimArray(range(10, 34), (2, 3, 4)) assert md[:, :, 0].tomatrix() == Matrix([[10, 14, 18], [22, 26, 30]]) assert md[0, 1:2, :].tomatrix() == Matrix([[14, 15, 16, 17]]) assert md[0, 1:3, :].tomatrix() == Matrix([[14, 15, 16, 17], [18, 19, 20, 21]]) @@ -338,8 +336,7 @@ def test_slices(): sd = MutableSparseNDimArray(range(10, 34), (2, 3, 4)) assert sd == MutableSparseNDimArray(md) - assert sd[:] == md._array - assert sd[:] == list(sd) + assert sd[:] == MutableSparseNDimArray(range(10, 34), (2, 3, 4)) assert sd[:, :, 0].tomatrix() == Matrix([[10, 14, 18], [22, 26, 30]]) assert sd[0, 1:2, :].tomatrix() == Matrix([[14, 15, 16, 17]]) assert sd[0, 1:3, :].tomatrix() == Matrix([[14, 15, 16, 17], [18, 19, 20, 21]]) diff --git a/sympy/tensor/tests/test_tensor.py b/sympy/tensor/tests/test_tensor.py index 02818166576e..6c413511f993 100644 --- a/sympy/tensor/tests/test_tensor.py +++ b/sympy/tensor/tests/test_tensor.py @@ -1277,21 +1277,23 @@ def test_valued_tensor_iter(): (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1, n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4) = _get_valued_base_test_variables() + list_BA = [Array([1, 2, 3, 4]), Array([5, 6, 7, 8]), Array([9, 0, -1, -2]), Array([-3, -4, -5, -6])] # iteration on VTensorHead assert list(A) == [E, px, py, pz] - assert list(ba_matrix) == list(BA) + assert list(ba_matrix) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 0, -1, -2, -3, -4, -5, -6] + assert list(BA) == list_BA # iteration on VTensMul assert list(A(i1)) == [E, px, py, pz] - assert list(BA(i1, i2)) == list(ba_matrix) - assert list(3 * BA(i1, i2)) == [3 * i for i in list(ba_matrix)] - assert list(-5 * BA(i1, i2)) == [-5 * i for i in list(ba_matrix)] + assert list(BA(i1, i2)) == list_BA + assert list(3 * BA(i1, i2)) == [3 * i for i in list_BA] + assert list(-5 * BA(i1, i2)) == [-5 * i for i in list_BA] # iteration on VTensAdd # A(i1) + A(i1) assert list(A(i1) + A(i1)) == [2E, 2px, 2py, 2pz] assert BA(i1, i2) - BA(i1, i2) == 0 - assert list(BA(i1, i2) - 2 * BA(i1, i2)) == [-i for i in list(ba_matrix)] + assert list(BA(i1, i2) - 2 * BA(i1, i2)) == [-i for i in list_BA] @filter_warnings_decorator		[ { "components": [ { "doc": "Flatten an iterable object to a list in a lazy-evaluation way.\n\nNotes\n=====\n\nThis class is an iterator with which the memory cost can be economised.\nOptimisation has been considered to ameliorate the performance for some\nspecific data types like DenseNDimArray an...	[ "test_sympy__tensor__array__arrayop__Flatten", "test_tensorproduct", "test_tensorcontraction", "test_derivative_by_array", "test_issue_emerged_while_discussing_10972", "test_array_permutedims", "test_sparse", "test_calculation", "test_slices", "test_valued_tensor_iter" ]	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> New __iter__ for Array module <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed The array iteration is modified to have a new behavior: Before: ```python >>> a = Array([[1, 2], [3, 4]]) >>> for i in a: ... print(i) ... 1 2 3 4 ``` Now: ```python >>> a = Array([[1, 2], [3, 4]]) >>> for i in a: ... print(i) ... [1, 2] [3, 4] ``` Besides, the iteration over each item is moved to a new object named `nditer` : ```python >>> from sympy.tensor.array.nditer import nditer >>> for i in nditer(a): ... print(i) ... 1 2 3 2 3 4 ``` #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * tensor * Modified __iter__ function and added new class named nditer <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/tensor/array/arrayop.py] (definition of Flatten:) class Flatten(Basic): """Flatten an iterable object to a list in a lazy-evaluation way. Notes ===== This class is an iterator with which the memory cost can be economised. Optimisation has been considered to ameliorate the performance for some specific data types like DenseNDimArray and SparseNDimArray. Examples ======== >>> from sympy.tensor.array.arrayop import Flatten >>> from sympy.tensor.array import Array >>> A = Array(range(6)).reshape(2, 3) >>> Flatten(A) Flatten([[0, 1, 2], [3, 4, 5]]) >>> [i for i in Flatten(A)] [0, 1, 2, 3, 4, 5]""" (definition of Flatten.__init__:) def __init__(self, iterable): (definition of Flatten.__iter__:) def __iter__(self): (definition of Flatten.__next__:) def __next__(self): (definition of Flatten.next:) def next(self): [end of new definitions in sympy/tensor/array/arrayop.py] [start of new definitions in sympy/tensor/array/ndim_array.py] (definition of NDimArray.__iter__:) def __iter__(self): (definition of NDimArray.__iter__.iterator:) def iterator(): [end of new definitions in sympy/tensor/array/ndim_array.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-17306	17,306	sympy/sympy	1.5	d3c1050bae5b6caeeacd03efbe25d3a57ff371a3	2019-07-31T14:29:29Z	diff --git a/sympy/stats/__init__.py b/sympy/stats/__init__.py index 0527237d119a..fbda90016983 100644 --- a/sympy/stats/__init__.py +++ b/sympy/stats/__init__.py @@ -100,6 +100,7 @@ GaussianUnitaryEnsemble, GaussianOrthogonalEnsemble, GaussianSymplecticEnsemble, + JointEigenDistribution, joint_eigen_distribution, level_spacing_distribution ) diff --git a/sympy/stats/random_matrix_models.py b/sympy/stats/random_matrix_models.py index 277e20eecf47..27d3e9c66d17 100644 --- a/sympy/stats/random_matrix_models.py +++ b/sympy/stats/random_matrix_models.py @@ -1,10 +1,12 @@ from __future__ import print_function, division from sympy import (Basic, exp, pi, Lambda, Trace, S, MatrixSymbol, Integral, - gamma, Product, Dummy, Sum, Abs, IndexedBase) + gamma, Product, Dummy, Sum, Abs, IndexedBase, Matrix) from sympy.core.sympify import _sympify from sympy.multipledispatch import dispatch -from sympy.stats.rv import _symbol_converter, Density, RandomMatrixSymbol +from sympy.stats.rv import (_symbol_converter, Density, RandomMatrixSymbol, + RandomSymbol) +from sympy.stats.joint_rv_types import JointDistributionHandmade from sympy.stats.random_matrix import RandomMatrixPSpace from sympy.tensor.array import ArrayComprehension @@ -14,6 +16,7 @@ 'GaussianOrthogonalEnsemble', 'GaussianSymplecticEnsemble', 'joint_eigen_distribution', + 'JointEigenDistribution', 'level_spacing_distribution' ] @@ -184,7 +187,6 @@ def level_spacing_distribution(self): f = ((S(2)18)/((S(3)6)(pi3)))(s*4)exp((-64/(9pi))s2) return Lambda(s, f) -@dispatch(RandomMatrixSymbol) def joint_eigen_distribution(mat): """ For obtaining joint probability distribution @@ -207,11 +209,47 @@ def joint_eigen_distribution(mat): >>> from sympy.stats import GaussianUnitaryEnsemble as GUE >>> from sympy.stats import joint_eigen_distribution >>> U = GUE('U', 2) - >>> joint_eigen_dsitribution(U) + >>> joint_eigen_distribution(U) Lambda((l[1], l[2]), exp(-l[1]2 - l[2]*2)Product(Abs(l[_i] - l[_j])2, (_j, _i + 1, 2), (_i, 1, 1))/pi) """ + if not isinstance(mat, RandomMatrixSymbol): + raise ValueError("%s is not of type, RandomMatrixSymbol."%(mat)) return mat.pspace.model.joint_eigen_distribution() +def JointEigenDistribution(mat): + """ + Creates joint distribution of eigen values of matrices with random + expressions. + + Parameters + ========== + + mat: Matrix + The matrix under consideration + + Returns + ======= + + JointDistributionHandmade + + Examples + ======== + + >>> from sympy.stats import Normal, JointEigenDistribution + >>> from sympy import Matrix + >>> A = [[Normal('A00', 0, 1), Normal('A01', 0, 1)], + ... [Normal('A10', 0, 1), Normal('A11', 0, 1)]] + >>> JointEigenDistribution(Matrix(A)) + JointDistributionHandmade(-sqrt(A002 - 2A00A11 + 4A01A10 + A112)/2 + + A00/2 + A11/2, sqrt(A002 - 2A00A11 + 4A01A10 + A11*2)/2 + A00/2 + A11/2) + + """ + eigenvals = mat.eigenvals(multiple=True) + if any(not eigenval.has(RandomSymbol) for eigenval in set(eigenvals)): + raise ValueError("Eigen values don't have any random expression, " + "joint distribution cannot be generated.") + return JointDistributionHandmade(eigenvals) + def level_spacing_distribution(mat): """ For obtaining distribution of level spacings.	diff --git a/sympy/stats/tests/test_random_matrix.py b/sympy/stats/tests/test_random_matrix.py index 2984692fa735..8402e45a2bb0 100644 --- a/sympy/stats/tests/test_random_matrix.py +++ b/sympy/stats/tests/test_random_matrix.py @@ -1,10 +1,13 @@ from sympy import (sqrt, exp, Trace, pi, S, Integral, MatrixSymbol, Lambda, - Dummy, Product, Sum, Abs, IndexedBase) + Dummy, Product, Sum, Abs, IndexedBase, Matrix) from sympy.stats import (GaussianUnitaryEnsemble as GUE, density, GaussianOrthogonalEnsemble as GOE, GaussianSymplecticEnsemble as GSE, joint_eigen_distribution, - level_spacing_distribution) + JointEigenDistribution, + level_spacing_distribution, + Normal, Beta) +from sympy.stats.joint_rv import JointDistributionHandmade from sympy.stats.rv import RandomMatrixSymbol, Density from sympy.stats.random_matrix_models import GaussianEnsemble from sympy.utilities.pytest import raises @@ -58,3 +61,11 @@ def test_GaussianSymplecticEnsemble(): Product(Abs(l[i] - l[j])*4, (j, i + 1, 3), (i, 1, 2))/(5pi*(S(3)/2)))) s = Dummy('s') assert level_spacing_distribution(G).dummy_eq(Lambda(s, S(262144)s*4exp(-64s2/(9pi))/(729pi3))) + +def test_JointEigenDistribution(): + A = Matrix([[Normal('A00', 0, 1), Normal('A01', 1, 1)], + [Beta('A10', 1, 1), Beta('A11', 1, 1)]]) + JointEigenDistribution(A) == \ + JointDistributionHandmade(-sqrt(A[0, 0]2 - 2A[0, 0]A[1, 1] + 4A[0, 1]A[1, 0] + A[1, 1]2)/2 + + A[0, 0]/2 + A[1, 1]/2, sqrt(A[0, 0]2 - 2A[0, 0]A[1, 1] + 4A[0, 1]A[1, 0] + A[1, 1]*2)/2 + A[0, 0]/2 + A[1, 1]/2) + raises(ValueError, lambda: JointEigenDistribution(Matrix([[1, 0], [2, 1]])))		[ { "components": [ { "doc": "Creates joint distribution of eigen values of matrices with random\nexpressions.\n\nParameters\n==========\n\nmat: Matrix\n The matrix under consideration\n\nReturns\n=======\n\nJointDistributionHandmade\n\nExamples\n========\n\n>>> from sympy.stats import Normal, Jo...	[ "test_GaussianEnsemble", "test_GaussianUnitaryEnsemble", "test_GaussianOrthogonalEnsemble", "test_GaussianSymplecticEnsemble" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Matrices with random expressions <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed N/A #### Other comments ping @Upabjojr @sidhantnagpal #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * stats * Matrices with random expressions have been added in `sympy.stats`. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/random_matrix_models.py] (definition of JointEigenDistribution:) def JointEigenDistribution(mat): """Creates joint distribution of eigen values of matrices with random expressions. Parameters ========== mat: Matrix The matrix under consideration Returns ======= JointDistributionHandmade Examples ======== >>> from sympy.stats import Normal, JointEigenDistribution >>> from sympy import Matrix >>> A = [[Normal('A00', 0, 1), Normal('A01', 0, 1)], ... [Normal('A10', 0, 1), Normal('A11', 0, 1)]] >>> JointEigenDistribution(Matrix(A)) JointDistributionHandmade(-sqrt(A00*2 - 2A00A11 + 4A01A10 + A112)/2 + A00/2 + A11/2, sqrt(A002 - 2A00A11 + 4A01A10 + A11*2)/2 + A00/2 + A11/2)""" [end of new definitions in sympy/stats/random_matrix_models.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-17304	17,304	sympy/sympy	1.5	1b99ff5cc724f195265ec93f7d56b782c82dcb23	2019-07-31T14:17:59Z	diff --git a/sympy/stats/__init__.py b/sympy/stats/__init__.py index fbda90016983..f1ca9b8720f6 100644 --- a/sympy/stats/__init__.py +++ b/sympy/stats/__init__.py @@ -96,6 +96,10 @@ from . import random_matrix_models from .random_matrix_models import ( + CircularEnsemble, + CircularUnitaryEnsemble, + CircularOrthogonalEnsemble, + CircularSymplecticEnsemble, GaussianEnsemble, GaussianUnitaryEnsemble, GaussianOrthogonalEnsemble, diff --git a/sympy/stats/random_matrix_models.py b/sympy/stats/random_matrix_models.py index 27d3e9c66d17..e86c969eb61d 100644 --- a/sympy/stats/random_matrix_models.py +++ b/sympy/stats/random_matrix_models.py @@ -1,9 +1,8 @@ from __future__ import print_function, division from sympy import (Basic, exp, pi, Lambda, Trace, S, MatrixSymbol, Integral, - gamma, Product, Dummy, Sum, Abs, IndexedBase, Matrix) + gamma, Product, Dummy, Sum, Abs, IndexedBase, Matrix, I) from sympy.core.sympify import _sympify -from sympy.multipledispatch import dispatch from sympy.stats.rv import (_symbol_converter, Density, RandomMatrixSymbol, RandomSymbol) from sympy.stats.joint_rv_types import JointDistributionHandmade @@ -11,6 +10,10 @@ from sympy.tensor.array import ArrayComprehension __all__ = [ + 'CircularEnsemble', + 'CircularUnitaryEnsemble', + 'CircularOrthogonalEnsemble', + 'CircularSymplecticEnsemble', 'GaussianEnsemble', 'GaussianUnitaryEnsemble', 'GaussianOrthogonalEnsemble', @@ -22,24 +25,11 @@ class RandomMatrixEnsemble(Basic): """ - Abstract class for random matrix ensembles. - It acts as an umbrella for all the ensembles + Base class for random matrix ensembles. + It acts as an umbrella and contains + the methods common to all the ensembles defined in sympy.stats.random_matrix_models. """ - pass - -class GaussianEnsemble(RandomMatrixEnsemble): - """ - Abstract class for Gaussian ensembles. - Contains the properties common to all the - gaussian ensembles. - - References - ========== - - .. [1] https://en.wikipedia.org/wiki/Random_matrix#Gaussian_ensembles - .. [2] https://arxiv.org/pdf/1712.07903.pdf - """ def __new__(cls, sym, dim=None): sym, dim = _symbol_converter(sym), _sympify(dim) if dim.is_integer == False: @@ -55,6 +45,18 @@ def __new__(cls, sym, dim=None): def density(self, expr): return Density(expr) +class GaussianEnsemble(RandomMatrixEnsemble): + """ + Abstract class for Gaussian ensembles. + Contains the properties common to all the + gaussian ensembles. + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Random_matrix#Gaussian_ensembles + .. [2] https://arxiv.org/pdf/1712.07903.pdf + """ def _compute_normalization_constant(self, beta, n): """ Helper function for computing normalization @@ -74,7 +76,7 @@ def _compute_normalization_constant(self, beta, n): term3 = (2pi)(n/2) return term1 term2 * term3 - def _compute_joint_eigen_dsitribution(self, beta): + def _compute_joint_eigen_distribution(self, beta): """ Helper function for computing the joint probability distribution of eigen values @@ -116,7 +118,7 @@ def density(self, expr): return Lambda(H, exp(-S(n)/2 * Trace(H*2))/ZGUE) def joint_eigen_distribution(self): - return self._compute_joint_eigen_dsitribution(2) + return self._compute_joint_eigen_distribution(S(2)) def level_spacing_distribution(self): s = Dummy('s') @@ -148,7 +150,7 @@ def density(self, expr): return Lambda(H, exp(-S(n)/4 Trace(H*2))/ZGOE) def joint_eigen_distribution(self): - return self._compute_joint_eigen_dsitribution(1) + return self._compute_joint_eigen_distribution(S(1)) def level_spacing_distribution(self): s = Dummy('s') @@ -180,13 +182,117 @@ def density(self, expr): return Lambda(H, exp(-S(n) Trace(H2))/ZGSE) def joint_eigen_distribution(self): - return self._compute_joint_eigen_dsitribution(4) + return self._compute_joint_eigen_distribution(S(4)) def level_spacing_distribution(self): s = Dummy('s') f = ((S(2)18)/((S(3)*6)(pi*3)))(s*4)exp((-64/(9pi))s*2) return Lambda(s, f) +class CircularEnsemble(RandomMatrixEnsemble): + """ + Abstract class for Circular ensembles. + Contains the properties and methods + common to all the circular ensembles. + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Circular_ensemble + """ + def density(self, expr): + # TODO : Add support for Lie groups(as extensions of sympy.diffgeom) + # and define measures on them + raise NotImplementedError("Support for Haar measure hasn't been " + "implemented yet, therefore the density of " + "%s cannot be computed."%(self)) + + def _compute_joint_eigen_distribution(self, beta): + """ + Helper function to compute the joint distribution of phases + of the complex eigen values of matrices belonging to any + circular ensembles. + """ + n = self.dimension + Zbn = ((2pi)*n)(gamma(betan/2 + 1)/S((gamma(beta/2 + 1)))n) + t = IndexedBase('t') + i, j, k = (Dummy('i', integer=True), Dummy('j', integer=True), + Dummy('k', integer=True)) + syms = ArrayComprehension(t[i], (i, 1, n)).doit() + f = Product(Product(Abs(exp(It[k]) - exp(It[j]))beta, (j, k + 1, n)).doit(), + (k, 1, n - 1)).doit() + return Lambda(syms, f/Zbn) + +class CircularUnitaryEnsemble(CircularEnsemble): + """ + Represents Cicular Unitary Ensembles. + + Examples + ======== + + >>> from sympy.stats import CircularUnitaryEnsemble as CUE, density + >>> from sympy.stats import joint_eigen_distribution + >>> C = CUE('U', 1) + >>> joint_eigen_distribution(C) + Lambda(t[1], Product(Abs(exp(It[_j]) - exp(It[_k]))2, (_j, _k + 1, 1), (_k, 1, 0))/(2pi)) + + Note + ==== + + As can be seen above in the example, density of CiruclarUnitaryEnsemble + is not evaluated becuase the exact definition is based on haar measure of + unitary group which is not unique. + """ + def joint_eigen_distribution(self): + return self._compute_joint_eigen_distribution(S(2)) + +class CircularOrthogonalEnsemble(CircularEnsemble): + """ + Represents Cicular Orthogonal Ensembles. + + Examples + ======== + + >>> from sympy.stats import CircularOrthogonalEnsemble as COE, density + >>> from sympy.stats import joint_eigen_distribution + >>> C = COE('O', 1) + >>> joint_eigen_distribution(C) + Lambda(t[1], Product(Abs(exp(It[_j]) - exp(It[_k])), (_j, _k + 1, 1), (_k, 1, 0))/(2pi)) + + Note + ==== + + As can be seen above in the example, density of CiruclarOrthogonalEnsemble + is not evaluated becuase the exact definition is based on haar measure of + unitary group which is not unique. + """ + def joint_eigen_distribution(self): + return self._compute_joint_eigen_distribution(S(1)) + +class CircularSymplecticEnsemble(CircularEnsemble): + """ + Represents Cicular Symplectic Ensembles. + + Examples + ======== + + >>> from sympy.stats import CircularSymplecticEnsemble as CSE, density + >>> from sympy.stats import joint_eigen_distribution + >>> C = CSE('S', 1) + >>> joint_eigen_distribution(C) + Lambda(t[1], Product(Abs(exp(It[_j]) - exp(It[_k]))4, (_j, _k + 1, 1), (_k, 1, 0))/(2pi)) + + Note + ==== + + As can be seen above in the example, density of CiruclarSymplecticEnsemble + is not evaluated becuase the exact definition is based on haar measure of + unitary group which is not unique. + """ + + def joint_eigen_distribution(self): + return self._compute_joint_eigen_distribution(S(4)) + def joint_eigen_distribution(mat): """ For obtaining joint probability distribution	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index bd8178144048..3d3401813579 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1621,11 +1621,11 @@ def test_sympy__stats__stochastic_process_types__ContinuousMarkovChain(): def test_sympy__stats__random_matrix__RandomMatrixPSpace(): from sympy.stats.random_matrix import RandomMatrixPSpace from sympy.stats.random_matrix_models import RandomMatrixEnsemble - assert _test_args(RandomMatrixPSpace('P', RandomMatrixEnsemble())) + assert _test_args(RandomMatrixPSpace('P', RandomMatrixEnsemble('R', 3))) def test_sympy__stats__random_matrix_models__RandomMatrixEnsemble(): from sympy.stats.random_matrix_models import RandomMatrixEnsemble - assert _test_args(RandomMatrixEnsemble()) + assert _test_args(RandomMatrixEnsemble('R', 3)) def test_sympy__stats__random_matrix_models__GaussianEnsemble(): from sympy.stats.random_matrix_models import GaussianEnsemble @@ -1643,6 +1643,22 @@ def test_sympy__stats__random_matrix_models__GaussianSymplecticEnsemble(): from sympy.stats import GaussianSymplecticEnsemble assert _test_args(GaussianSymplecticEnsemble('U', 3)) +def test_sympy__stats__random_matrix_models__CircularEnsemble(): + from sympy.stats import CircularEnsemble + assert _test_args(CircularEnsemble('C', 3)) + +def test_sympy__stats__random_matrix_models__CircularUnitaryEnsemble(): + from sympy.stats import CircularUnitaryEnsemble + assert _test_args(CircularUnitaryEnsemble('U', 3)) + +def test_sympy__stats__random_matrix_models__CircularOrthogonalEnsemble(): + from sympy.stats import CircularOrthogonalEnsemble + assert _test_args(CircularOrthogonalEnsemble('O', 3)) + +def test_sympy__stats__random_matrix_models__CircularSymplecticEnsemble(): + from sympy.stats import CircularSymplecticEnsemble + assert _test_args(CircularSymplecticEnsemble('S', 3)) + def test_sympy__core__symbol__Dummy(): from sympy.core.symbol import Dummy assert _test_args(Dummy('t')) diff --git a/sympy/stats/tests/test_random_matrix.py b/sympy/stats/tests/test_random_matrix.py index 8402e45a2bb0..ef7f502c745f 100644 --- a/sympy/stats/tests/test_random_matrix.py +++ b/sympy/stats/tests/test_random_matrix.py @@ -1,9 +1,13 @@ from sympy import (sqrt, exp, Trace, pi, S, Integral, MatrixSymbol, Lambda, - Dummy, Product, Sum, Abs, IndexedBase, Matrix) + Dummy, Product, Sum, Abs, IndexedBase, Matrix, I) from sympy.stats import (GaussianUnitaryEnsemble as GUE, density, GaussianOrthogonalEnsemble as GOE, GaussianSymplecticEnsemble as GSE, joint_eigen_distribution, + level_spacing_distribution, + CircularUnitaryEnsemble as CUE, + CircularOrthogonalEnsemble as COE, + CircularSymplecticEnsemble as CSE, JointEigenDistribution, level_spacing_distribution, Normal, Beta) @@ -62,6 +66,39 @@ def test_GaussianSymplecticEnsemble(): s = Dummy('s') assert level_spacing_distribution(G).dummy_eq(Lambda(s, S(262144)s4exp(-64s2/(9pi))/(729pi3))) +def test_CircularUnitaryEnsemble(): + CU = CUE('U', 3) + j, k = (Dummy('j', integer=True, positive=True), + Dummy('k', integer=True, positive=True)) + t = IndexedBase('t') + assert joint_eigen_distribution(CU).dummy_eq( + Lambda((t[1], t[2], t[3]), + Product(Abs(exp(It[j]) - exp(It[k]))2, + (j, k + 1, 3), (k, 1, 2))/(48pi*3)) + ) + +def test_CircularOrthogonalEnsemble(): + CO = COE('U', 3) + j, k = (Dummy('j', integer=True, positive=True), + Dummy('k', integer=True, positive=True)) + t = IndexedBase('t') + assert joint_eigen_distribution(CO).dummy_eq( + Lambda((t[1], t[2], t[3]), + Product(Abs(exp(It[j]) - exp(It[k])), + (j, k + 1, 3), (k, 1, 2))/(48pi*2)) + ) + +def test_CircularSymplecticEnsemble(): + CS = CSE('U', 3) + j, k = (Dummy('j', integer=True, positive=True), + Dummy('k', integer=True, positive=True)) + t = IndexedBase('t') + assert joint_eigen_distribution(CS).dummy_eq( + Lambda((t[1], t[2], t[3]), + Product(Abs(exp(It[j]) - exp(It[k]))4, + (j, k + 1, 3), (k, 1, 2))/(720pi**3)) + ) + def test_JointEigenDistribution(): A = Matrix([[Normal('A00', 0, 1), Normal('A01', 1, 1)], [Beta('A10', 1, 1), Beta('A11', 1, 1)]])		[ { "components": [ { "doc": "", "lines": [ 33, 40 ], "name": "RandomMatrixEnsemble.__new__", "signature": "def __new__(cls, sym, dim=None):", "type": "function" }, { "doc": "", "lines": [ 45, ...	[ "test_sympy__stats__random_matrix_models__RandomMatrixEnsemble", "test_sympy__stats__random_matrix_models__CircularEnsemble", "test_sympy__stats__random_matrix_models__CircularUnitaryEnsemble", "test_sympy__stats__random_matrix_models__CircularOrthogonalEnsemble", "test_sympy__stats__random_matrix_models__C...	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added circular ensembles <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed Circular ensembles have been added. #### Other comments More features will be added, if possible. @Upabjojr @sidhantnagpal I am facing a problem(well the last option will be to keep it unevaluated) in exactly defining the density, since it is based on Haar measure which is not unique. Please let me know of any thing available in the literature so that I can do some improvements. I am also right now doing some searching on Google. #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * stats * Circular ensembles have been added in `sympy.stats`. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/random_matrix_models.py] (definition of RandomMatrixEnsemble.__new__:) def __new__(cls, sym, dim=None): (definition of RandomMatrixEnsemble.density:) def density(self, expr): (definition of GaussianEnsemble._compute_joint_eigen_distribution:) def _compute_joint_eigen_distribution(self, beta): """Helper function for computing the joint probability distribution of eigen values of the random matrix.""" (definition of CircularEnsemble:) class CircularEnsemble(RandomMatrixEnsemble): """Abstract class for Circular ensembles. Contains the properties and methods common to all the circular ensembles. References ========== .. [1] https://en.wikipedia.org/wiki/Circular_ensemble""" (definition of CircularEnsemble.density:) def density(self, expr): (definition of CircularEnsemble._compute_joint_eigen_distribution:) def _compute_joint_eigen_distribution(self, beta): """Helper function to compute the joint distribution of phases of the complex eigen values of matrices belonging to any circular ensembles.""" (definition of CircularUnitaryEnsemble:) class CircularUnitaryEnsemble(CircularEnsemble): """Represents Cicular Unitary Ensembles. Examples ======== >>> from sympy.stats import CircularUnitaryEnsemble as CUE, density >>> from sympy.stats import joint_eigen_distribution >>> C = CUE('U', 1) >>> joint_eigen_distribution(C) Lambda(t[1], Product(Abs(exp(It[_j]) - exp(It[_k]))*2, (_j, _k + 1, 1), (_k, 1, 0))/(2pi)) Note ==== As can be seen above in the example, density of CiruclarUnitaryEnsemble is not evaluated becuase the exact definition is based on haar measure of unitary group which is not unique.""" (definition of CircularUnitaryEnsemble.joint_eigen_distribution:) def joint_eigen_distribution(self): (definition of CircularOrthogonalEnsemble:) class CircularOrthogonalEnsemble(CircularEnsemble): """Represents Cicular Orthogonal Ensembles. Examples ======== >>> from sympy.stats import CircularOrthogonalEnsemble as COE, density >>> from sympy.stats import joint_eigen_distribution >>> C = COE('O', 1) >>> joint_eigen_distribution(C) Lambda(t[1], Product(Abs(exp(It[_j]) - exp(It[_k])), (_j, _k + 1, 1), (_k, 1, 0))/(2pi)) Note ==== As can be seen above in the example, density of CiruclarOrthogonalEnsemble is not evaluated becuase the exact definition is based on haar measure of unitary group which is not unique.""" (definition of CircularOrthogonalEnsemble.joint_eigen_distribution:) def joint_eigen_distribution(self): (definition of CircularSymplecticEnsemble:) class CircularSymplecticEnsemble(CircularEnsemble): """Represents Cicular Symplectic Ensembles. Examples ======== >>> from sympy.stats import CircularSymplecticEnsemble as CSE, density >>> from sympy.stats import joint_eigen_distribution >>> C = CSE('S', 1) >>> joint_eigen_distribution(C) Lambda(t[1], Product(Abs(exp(It[_j]) - exp(It[_k]))4, (_j, _k + 1, 1), (_k, 1, 0))/(2pi)) Note ==== As can be seen above in the example, density of CiruclarSymplecticEnsemble is not evaluated becuase the exact definition is based on haar measure of unitary group which is not unique.""" (definition of CircularSymplecticEnsemble.joint_eigen_distribution:) def joint_eigen_distribution(self): [end of new definitions in sympy/stats/random_matrix_models.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
joke2k__faker-984	984	joke2k/faker	null	e93e4d1e5bfdb1cfa08ae5112466494d7ec1718b	2019-07-30T11:01:14Z	diff --git a/faker/providers/geo/pt_PT/__init__.py b/faker/providers/geo/pt_PT/__init__.py new file mode 100644 index 0000000000..7415c5cbfe --- /dev/null +++ b/faker/providers/geo/pt_PT/__init__.py @@ -0,0 +1,30 @@ +# coding=utf-8 + +from __future__ import unicode_literals +from .. import Provider as GeoProvider + + +class Provider(GeoProvider): + + nationalities = ( + "Afegã", "Albanesa", "Arménia", "Angolana", "Argentina", "Austríaca", "Australiana", "Azerbaijã", "Belga", + "Bulgara", "Boliviana", "Brasileira", "Bielorussa", "Canadiana", "Congolesa (República Democrática do Congo)", + "Congolesa (República do Congo)", "Suíça", "Marfinense", "Chilena", "Chinesa", "Colombiana", "Costa-Riquenha", + "Cubana", "Cabo-verdiana", "Cipriota", "Checa", "Alemã", "Dinamarquesa", "Dominicana", "Argelina", + "Equatoriana", "Estónia", "Egípcia", "Espanhola", "Etíope", "Finlândesa", "Francesa", "Grega", + "Guineense (Bissau)", "Croata", "Húngara", "Indonésia", "Irlandesa", "Israelita", "Indiana", "Iraquiana", + "Iraniana", "Islandesa", "Italiana", "Jamaicana", "Japonesa", "Queniana", "Coreana", "Libanesa", "Lituana", + "Luxemburguesa", "Letã", "Marroquina", "Moldava", "Birmanesa", "Maltesa", "Mexicana", "Moçambicana", + "Nigeriana", "Holandesa", "Norueguesa", "Nepalesa", "Neozelandesa", "Peruana", "Filipina", "Paquistanesa", + "Polaca", "Portuguesa", "Paraguaia", "Romena", "Russa", "Ruandesa", "Sudanesa", "Sueca", "Eslovena", "Eslovaca", + "Senegalesa", "Somali", "Santomense", "Salvadorenha", "Tailandesa", "Tunisina", "Turca", "Ucraniana", + "Britânica", "Americana", "Uruguaia", "Venezuelana", "Vietnamita", "Sul-Africana", "Sérvia", "Andorrenha", + "Bósnia", "Camaronesa", "Georgiana", "Ganesa", "Gambiana", "Hondurenha", "Haitiana", "Cazaque", "Libanesa ", + "Monegasca", "Maliana", "Mongol", "Mauritana", "Malaia", "Panamiana", "Saudita", "Singapurense", "Togolesa", + ) + + def nationality(self): + """ + :example 'Portuguesa' + """ + return self.random_element(self.nationalities)	diff --git a/tests/providers/test_geo.py b/tests/providers/test_geo.py index eb4b2fa34f..5b152eda5f 100644 --- a/tests/providers/test_geo.py +++ b/tests/providers/test_geo.py @@ -5,8 +5,10 @@ import re import unittest from decimal import Decimal +from six import string_types from faker import Faker +from faker.providers.geo.pt_PT import Provider as PtPtProvider class TestGlobal(unittest.TestCase): @@ -93,3 +95,14 @@ def test_local_latitude(self): def test_local_longitude(self): local_longitude = self.factory.local_longitude() assert re.match(r"1[1-5]\.\d+", str(local_longitude)) + + +class TestPtPT(unittest.TestCase): + + def setUp(self): + self.factory = Faker('pt_PT') + + def test_nationality(self): + nationality = self.factory.nationality() + assert isinstance(nationality, string_types) + assert nationality in PtPtProvider.nationalities		[ { "components": [ { "doc": "", "lines": [ 7, 30 ], "name": "Provider", "signature": "class Provider(GeoProvider):", "type": "class" }, { "doc": ":example 'Portuguesa'", "lines": [ 26, 30 ...	[ "tests/providers/test_geo.py::TestGlobal::test_local_latlng", "tests/providers/test_geo.py::TestEnUS::test_coordinate", "tests/providers/test_geo.py::TestEnUS::test_coordinate_centered", "tests/providers/test_geo.py::TestEnUS::test_coordinate_rounded", "tests/providers/test_geo.py::TestEnUS::test_latitude",...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added nationalities for locale pt_PT. Tests are also provided ### What does this changes It adds nationalities in portuguese Tests are also provided Brief summary of the changes It adds nationalities in portuguese Tests are also provided ### What was wrong Nothing, it is just missing this piece of data ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/geo/pt_PT/__init__.py] (definition of Provider:) class Provider(GeoProvider): (definition of Provider.nationality:) def nationality(self): """:example 'Portuguesa'""" [end of new definitions in faker/providers/geo/pt_PT/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		6edfdbf6ae90b0153309e3bf066aa3b2d16494a7
sympy__sympy-17266	17,266	sympy/sympy	1.5	2d700c4b3c0871a26741456787b0555eed9d5546	2019-07-26T06:35:30Z	diff --git a/.gitignore b/.gitignore index 2614e1546e15..db4a22815e50 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,8 @@ # track a file that is ignored for some reason, you have to use # "git add -f". See "git help gitignore" for more information. +# Virtualenv +/.venv/ # Regular Python bytecode file .pyc diff --git a/doc/src/modules/printing.rst b/doc/src/modules/printing.rst index 2adf23a024cb..4729ed9a25b6 100644 --- a/doc/src/modules/printing.rst +++ b/doc/src/modules/printing.rst @@ -301,6 +301,20 @@ Mathematica code printing .. autofunction:: sympy.printing.mathematica.mathematica_code +Maple code printing +------------------- + +.. module:: sympy.printing.maple + +.. autoclass:: sympy.printing.maple.MapleCodePrinter + :members: + + .. autoattribute:: MapleCodePrinter.printmethod + +.. autofunction:: sympy.printing.maple.maple_code + +.. autofunction:: sympy.printing.maple.print_maple_code + Javascript Code printing ------------------------ diff --git a/sympy/printing/__init__.py b/sympy/printing/__init__.py index 2b73f8359d16..39a66b511292 100644 --- a/sympy/printing/__init__.py +++ b/sympy/printing/__init__.py @@ -67,3 +67,6 @@ from .dot import dotprint __all__ += ['dotprint'] + +from .maple import maple_code, print_maple_code +__all__ += ['maple_code', 'print_maple_code'] diff --git a/sympy/printing/maple.py b/sympy/printing/maple.py new file mode 100644 index 000000000000..67c63c0e2527 --- /dev/null +++ b/sympy/printing/maple.py @@ -0,0 +1,318 @@ +""" +Maple code printer + +The MapleCodePrinter converts single sympy expressions into single +Maple expressions, using the functions defined in the Maple objects where possible. + + +FIXME: This module is still under actively developed. Some functions may be not completed. +""" + +from __future__ import print_function, division + +from sympy.codegen.ast import Assignment +from sympy.core import S +from sympy.core.basic import Atom +from sympy.core.numbers import Integer, IntegerConstant +from sympy.core.compatibility import string_types, range +from sympy.printing.codeprinter import CodePrinter +from sympy.printing.precedence import precedence, PRECEDENCE + +import sympy + +_known_func_same_name = [ + 'sin', 'cos', 'tan', 'sec', 'csc', 'cot', 'sinh', 'cosh', 'tanh', 'sech', + 'csch', 'coth', 'exp', 'floor', 'factorial' +] + +known_functions = { + # Sympy -> Maple + 'Abs': 'abs', + 'log': 'ln', + 'asin': 'arcsin', + 'acos': 'arccos', + 'atan': 'arctan', + 'asec': 'arcsec', + 'acsc': 'arccsc', + 'acot': 'arccot', + 'asinh': 'arcsinh', + 'acosh': 'arccosh', + 'atanh': 'arctanh', + 'asech': 'arcsech', + 'acsch': 'arccsch', + 'acoth': 'arccoth', + 'ceiling': 'ceil', + + 'besseli': 'BesselI', + 'besselj': 'BesselJ', + 'besselk': 'BesselK', + 'bessely': 'BesselY', + 'hankelh1': 'HankelH1', + 'hankelh2': 'HankelH2', + 'airyai': 'AiryAi', + 'airybi': 'AiryBi' +} +for _func in _known_func_same_name: + known_functions[_func] = _func + +number_symbols = { + # Sympy -> Maple + S.Pi: 'Pi', + S.Exp1: 'exp(1)', + S.Catalan: 'Catalan', + S.EulerGamma: 'gamma', + S.GoldenRatio: '(1/2 + (1/2)sqrt(5))' +} + +spec_relational_ops = { + # Sympy -> Maple + '==': '=', + '!=': '<>' +} + +not_supported_symbol = [ + S.ComplexInfinity +] + +class MapleCodePrinter(CodePrinter): + """ + Printer which converts a sympy expression into a maple code. + """ + printmethod = "_maple" + language = "maple" + + _default_settings = { + 'order': None, + 'full_prec': 'auto', + 'human': True, + 'inline': True, + 'allow_unknown_functions': True, + } + + def __init__(self, settings=None): + if settings is None: + settings = dict() + super(MapleCodePrinter, self).__init__(settings) + self.known_functions = dict(known_functions) + userfuncs = settings.get('user_functions', {}) + self.known_functions.update(userfuncs) + + def _get_statement(self, codestring): + return "%s;" % codestring + + def _get_comment(self, text): + return "# {0}".format(text) + + def _declare_number_const(self, name, value): + return "{0} := {1};".format(name, + value.evalf(self._settings['precision'])) + + def _format_code(self, lines): + return lines + + def _print_tuple(self, expr): + return self._print(list(expr)) + + def _print_Tuple(self, expr): + return self._print(list(expr)) + + def _print_Assignment(self, expr): + lhs = self._print(expr.lhs) + rhs = self._print(expr.rhs) + return "{lhs} := {rhs}".format(lhs=lhs, rhs=rhs) + + def _print_Pow(self, expr, *kwargs): + PREC = precedence(expr) + if expr.exp == -1: + return '1/%s' % (self.parenthesize(expr.base, PREC)) + elif expr.exp == 0.5 or expr.exp == S(1) / 2: + return 'sqrt(%s)' % self._print(expr.base) + elif expr.exp == -0.5 or expr.exp == -S(1) / 2: + return '1/sqrt(%s)' % self._print(expr.base) + else: + return '{base}^{exp}'.format( + base=self.parenthesize(expr.base, PREC), + exp=self.parenthesize(expr.exp, PREC)) + + def _print_Piecewise(self, expr): + if (expr.args[-1].cond is not True) and (expr.args[-1].cond != S.BooleanTrue): + # We need the last conditional to be a True, otherwise the resulting + # function may not return a result. + raise ValueError("All Piecewise expressions must contain an " + "(expr, True) statement to be used as a default " + "condition. Without one, the generated " + "expression may not evaluate to anything under " + "some condition.") + _coup_list = [ + ("{c}, {e}".format(c=self._print(c), + e=self._print(e)) if c is not True and c is not S.BooleanTrue else "{e}".format( + e=self._print(e))) + for e, c in expr.args] + _inbrace = ', '.join(_coup_list) + return 'piecewise({_inbrace})'.format(_inbrace=_inbrace) + + def _print_Rational(self, expr): + p, q = int(expr.p), int(expr.q) + return "{p}/{q}".format(p=str(p), q=str(q)) + + def _print_Relational(self, expr): + PREC=precedence(expr) + lhs_code = self.parenthesize(expr.lhs, PREC) + rhs_code = self.parenthesize(expr.rhs, PREC) + op = expr.rel_op + if op in spec_relational_ops: + op = spec_relational_ops[op] + return "{lhs} {rel_op} {rhs}".format(lhs=lhs_code, rel_op=op, rhs=rhs_code) + + def _print_NumberSymbol(self, expr): + return number_symbols[expr] + + def _print_NegativeInfinity(self, expr): + return '-infinity' + + def _print_Infinity(self, expr): + return 'infinity' + + def _print_Idx(self, expr): + return self._print(expr.label) + + def _print_BooleanTrue(self, expr): + return "true" + + def _print_BooleanFalse(self, expr): + return "false" + + def _print_bool(self, expr): + return 'true' if expr else 'false' + + def _print_NaN(self, expr): + return 'undefined' + + def _get_matrix(self, expr, sparse=False): + if expr.cols == 0 or expr.rows == 0: + _strM = 'Matrix([], storage = {storage})'.format( + storage='sparse' if sparse else 'rectangular') + else: + _strM = 'Matrix({list}, storage = {storage})'.format( + list=self._print(expr.tolist()), + storage='sparse' if sparse else 'rectangular') + return _strM + + def _print_MatrixElement(self, expr): + return "{parent}[{i_maple}, {j_maple}]".format( + parent=self.parenthesize(expr.parent, PRECEDENCE["Atom"], strict=True), + i_maple=self._print(expr.i + 1), + j_maple=self._print(expr.j + 1)) + + def _print_MatrixBase(self, expr): + return self._get_matrix(expr, sparse=False) + + def _print_SparseMatrix(self, expr): + return self._get_matrix(expr, sparse=True) + + _print_Matrix = \ + _print_DenseMatrix = \ + _print_MutableDenseMatrix = \ + _print_ImmutableMatrix = \ + _print_ImmutableDenseMatrix = \ + _print_MatrixBase + _print_MutableSparseMatrix = \ + _print_ImmutableSparseMatrix = \ + _print_SparseMatrix + + def _print_Identity(self, expr): + if isinstance(expr.rows, Integer) or isinstance(expr.rows, IntegerConstant): + return self._print(sympy.SparseMatrix(expr)) + else: + return "Matrix({var_size}, shape = identity)".format(var_size=self._print(expr.rows)) + + def _print_MatMul(self, expr): + PREC=precedence(expr) + _fact_list = list(expr.args) + _const = None + if not ( + isinstance(_fact_list[0], sympy.MatrixBase) or isinstance( + _fact_list[0], sympy.MatrixExpr) or isinstance( + _fact_list[0], sympy.MatrixSlice) or isinstance( + _fact_list[0], sympy.MatrixSymbol)): + _const, _fact_list = _fact_list[0], _fact_list[1:] + + if _const is None or _const == 1: + return '.'.join(self.parenthesize(_m, PREC) for _m in _fact_list) + else: + return '{c}{m}'.format(c=_const, m='.'.join(self.parenthesize(_m, PREC) for _m in _fact_list)) + + def _print_MatPow(self, expr): + # This function requires LinearAlgebra Function in Maple + return 'MatrixPower({A}, {n})'.format(A=self._print(expr.base), n=self._print(expr.exp)) + + def _print_HadamardProduct(self, expr): + PREC = precedence(expr) + _fact_list = list(expr.args) + return ''.join(self.parenthesize(_m, PREC) for _m in _fact_list) + + def _print_Derivative(self, expr): + _f, (_var, _order) = expr.args + + if _order != 1: + _second_arg = '{var}${order}'.format(var=self._print(_var), + order=self._print(_order)) + else: + _second_arg = '{var}'.format(var=self._print(_var)) + return 'diff({func_expr}, {sec_arg})'.format(func_expr=self._print(_f), sec_arg=_second_arg) + + +def maple_code(expr, assign_to=None, settings): + r"""Converts ``expr`` to a string of Maple code. + + Parameters + ========== + + expr : Expr + A sympy expression to be converted. + assign_to : optional + When given, the argument is used as the name of the variable to which + the expression is assigned. Can be a string, ``Symbol``, + ``MatrixSymbol``, or ``Indexed`` type. This can be helpful for + expressions that generate multi-line statements. + precision : integer, optional + The precision for numbers such as pi [default=16]. + user_functions : dict, optional + A dictionary where keys are ``FunctionClass`` instances and values are + their string representations. Alternatively, the dictionary value can + be a list of tuples i.e. [(argument_test, cfunction_string)]. See + below for examples. + human : bool, optional + If True, the result is a single string that may contain some constant + declarations for the number symbols. If False, the same information is + returned in a tuple of (symbols_to_declare, not_supported_functions, + code_text). [default=True]. + contract: bool, optional + If True, ``Indexed`` instances are assumed to obey tensor contraction + rules and the corresponding nested loops over indices are generated. + Setting contract=False will not generate loops, instead the user is + responsible to provide values for the indices in the code. + [default=True]. + inline: bool, optional + If True, we try to create single-statement code instead of multiple + statements. [default=True]. + + """ + return MapleCodePrinter(settings).doprint(expr, assign_to) + + +def print_maple_code(expr, settings): + """Prints the Maple representation of the given expression. + + See :func:`maple_code` for the meaning of the optional arguments. + + Examples + ======== + + >>> from sympy.printing.maple import print_maple_code + >>> from sympy import symbols + >>> x, y = symbols('x y') + >>> print_maple_code(x, assign_to=y) + y := x + """ + print(maple_code(expr, *settings))	diff --git a/sympy/printing/tests/test_maple.py b/sympy/printing/tests/test_maple.py new file mode 100644 index 000000000000..70fbcda0c3af --- /dev/null +++ b/sympy/printing/tests/test_maple.py @@ -0,0 +1,384 @@ +from sympy.core import (S, pi, oo, symbols, Function, Rational, Integer, + Tuple, Symbol, Eq, Ne, Le, Lt, Gt, Ge) +from sympy.core import EulerGamma, GoldenRatio, Catalan, Lambda, Mul, Pow +from sympy.functions import Piecewise, sqrt, ceiling, exp, sin, cos +from sympy.utilities.pytest import raises +from sympy.utilities.lambdify import implemented_function +from sympy.matrices import (eye, Matrix, MatrixSymbol, Identity, + HadamardProduct, SparseMatrix) +from sympy.functions.special.bessel import (jn, yn, besselj, bessely, besseli, + besselk, hankel1, hankel2, airyai, + airybi, airyaiprime, airybiprime) +from sympy.utilities.pytest import XFAIL + +from sympy import maple_code + +x, y, z = symbols('x,y,z') + + +def test_Integer(): + assert maple_code(Integer(67)) == "67" + assert maple_code(Integer(-1)) == "-1" + + +def test_Rational(): + assert maple_code(Rational(3, 7)) == "3/7" + assert maple_code(Rational(18, 9)) == "2" + assert maple_code(Rational(3, -7)) == "-3/7" + assert maple_code(Rational(-3, -7)) == "3/7" + assert maple_code(x + Rational(3, 7)) == "x + 3/7" + assert maple_code(Rational(3, 7) * x) == '(3/7)x' + + +def test_Relational(): + assert maple_code(Eq(x, y)) == "x = y" + assert maple_code(Ne(x, y)) == "x <> y" + assert maple_code(Le(x, y)) == "x <= y" + assert maple_code(Lt(x, y)) == "x < y" + assert maple_code(Gt(x, y)) == "x > y" + assert maple_code(Ge(x, y)) == "x >= y" + + +def test_Function(): + assert maple_code(sin(x) * cos(x)) == "sin(x)^cos(x)" + assert maple_code(abs(x)) == "abs(x)" + assert maple_code(ceiling(x)) == "ceil(x)" + + +def test_Pow(): + assert maple_code(x 3) == "x^3" + assert maple_code(x (y 3)) == "x^(y^3)" + + assert maple_code((x 3) y) == "(x^3)^y" + assert maple_code(x Rational(2, 3)) == 'x^(2/3)' + + g = implemented_function('g', Lambda(x, 2 * x)) + assert maple_code(1 / (g(x) * 3.5) (x - y x) / (x ** 2 + y)) == \ + "(3.52x)^(-x + y^x)/(x^2 + y)" + # For issue 14160 + assert maple_code(Mul(-2, x, Pow(Mul(y, y, evaluate=False), -1, evaluate=False), + evaluate=False)) == '-2x/(yy)' + + +def test_basic_ops(): + assert maple_code(x * y) == "xy" + assert maple_code(x + y) == "x + y" + assert maple_code(x - y) == "x - y" + assert maple_code(-x) == "-x" + + +def test_1_over_x_and_sqrt(): + # 1.0 and 0.5 would do something different in regular StrPrinter, + # but these are exact in IEEE floating point so no different here. + assert maple_code(1 / x) == '1/x' + assert maple_code(x * -1) == maple_code(x -1.0) == '1/x' + assert maple_code(1 / sqrt(x)) == '1/sqrt(x)' + assert maple_code(x -S.Half) == maple_code(x -0.5) == '1/sqrt(x)' + assert maple_code(sqrt(x)) == 'sqrt(x)' + assert maple_code(x S.Half) == maple_code(x 0.5) == 'sqrt(x)' + assert maple_code(1 / pi) == '1/Pi' + assert maple_code(pi -1) == maple_code(pi -1.0) == '1/Pi' + assert maple_code(pi -0.5) == '1/sqrt(Pi)' + + +def test_mix_number_mult_symbols(): + assert maple_code(3 * x) == "3x" + assert maple_code(pi x) == "Pix" + assert maple_code(3 / x) == "3/x" + assert maple_code(pi / x) == "Pi/x" + assert maple_code(x / 3) == '(1/3)x' + assert maple_code(x / pi) == "x/Pi" + assert maple_code(x * y) == "xy" + assert maple_code(3 x * y) == "3xy" + assert maple_code(3 * pi * x * y) == "3Pixy" + assert maple_code(x / y) == "x/y" + assert maple_code(3 x / y) == "3x/y" + assert maple_code(x y / z) == "xy/z" + assert maple_code(x / y z) == "xz/y" + assert maple_code(1 / x / y) == "1/(xy)" + assert maple_code(2 * pi * x / y / z) == "2Pix/(yz)" + assert maple_code(3 pi / x) == "3Pi/x" + assert maple_code(S(3) / 5) == "3/5" + assert maple_code(S(3) / 5 x) == '(3/5)x' + assert maple_code(x / y / z) == "x/(yz)" + assert maple_code((x + y) / z) == "(x + y)/z" + assert maple_code((x + y) / (z + x)) == "(x + y)/(x + z)" + assert maple_code((x + y) / EulerGamma) == '(x + y)/gamma' + assert maple_code(x / 3 / pi) == '(1/3)x/Pi' + assert maple_code(S(3) / 5 x * y / pi) == '(3/5)xy/Pi' + + +def test_mix_number_pow_symbols(): + assert maple_code(pi 3) == 'Pi^3' + assert maple_code(x 2) == 'x^2' + + assert maple_code(x (pi 3)) == 'x^(Pi^3)' + assert maple_code(x y) == 'x^y' + + assert maple_code(x (y z)) == 'x^(y^z)' + assert maple_code((x y) ** z) == '(x^y)^z' + + +def test_imag(): + I = S('I') + assert maple_code(I) == "I" + assert maple_code(5 * I) == "5I" + + assert maple_code((S(3) / 2) I) == "(3/2)I" + assert maple_code(3 + 4 I) == "3 + 4I" + + +def test_constants(): + assert maple_code(pi) == "Pi" + assert maple_code(oo) == "infinity" + assert maple_code(-oo) == "-infinity" + assert maple_code(S.NegativeInfinity) == "-infinity" + assert maple_code(S.NaN) == "undefined" + assert maple_code(S.Exp1) == "exp(1)" + assert maple_code(exp(1)) == "exp(1)" + + +def test_constants_other(): + assert maple_code(2 GoldenRatio) == '2(1/2 + (1/2)sqrt(5))' + assert maple_code(2 * Catalan) == '2Catalan' + assert maple_code(2 EulerGamma) == "2gamma" + + +def test_boolean(): + assert maple_code(x & y) == "x && y" + assert maple_code(x \| y) == "x \|\| y" + assert maple_code(~x) == "!x" + assert maple_code(x & y & z) == "x && y && z" + assert maple_code(x \| y \| z) == "x \|\| y \|\| z" + assert maple_code((x & y) \| z) == "z \|\| x && y" + assert maple_code((x \| y) & z) == "z && (x \|\| y)" + + +def test_Matrices(): + assert maple_code(Matrix(1, 1, [10])) == \ + 'Matrix([[10]], storage = rectangular)' + + A = Matrix([[1, sin(x / 2), abs(x)], + [0, 1, pi], + [0, exp(1), ceiling(x)]]) + expected = \ + 'Matrix(' \ + '[[1, sin((1/2)x), abs(x)],' \ + ' [0, 1, Pi],' \ + ' [0, exp(1), ceil(x)]], ' \ + 'storage = rectangular)' + assert maple_code(A) == expected + + # row and columns + assert maple_code(A[:, 0]) == \ + 'Matrix([[1], [0], [0]], storage = rectangular)' + assert maple_code(A[0, :]) == \ + 'Matrix([[1, sin((1/2)x), abs(x)]], storage = rectangular)' + assert maple_code(Matrix([[x, x - y, -y]])) == \ + 'Matrix([[x, x - y, -y]], storage = rectangular)' + + # empty matrices + assert maple_code(Matrix(0, 0, [])) == \ + 'Matrix([], storage = rectangular)' + assert maple_code(Matrix(0, 3, [])) == \ + 'Matrix([], storage = rectangular)' + +def test_SparseMatrices(): + assert maple_code(SparseMatrix(Identity(2))) == 'Matrix([[1, 0], [0, 1]], storage = sparse)' + + +def test_vector_entries_hadamard(): + # For a row or column, user might to use the other dimension + A = Matrix([[1, sin(2 / x), 3 pi / x / 5]]) + assert maple_code(A) == \ + 'Matrix([[1, sin(2/x), (3/5)Pi/x]], storage = rectangular)' + assert maple_code(A.T) == \ + 'Matrix([[1], [sin(2/x)], [(3/5)Pi/x]], storage = rectangular)' + + +def test_Matrices_entries_not_hadamard(): + A = Matrix([[1, sin(2 / x), 3 * pi / x / 5], [1, 2, x * y]]) + expected = \ + 'Matrix([[1, sin(2/x), (3/5)Pi/x], [1, 2, xy]], ' \ + 'storage = rectangular)' + assert maple_code(A) == expected + + +def test_MatrixSymbol(): + n = Symbol('n', integer=True) + A = MatrixSymbol('A', n, n) + B = MatrixSymbol('B', n, n) + assert maple_code(A * B) == "A.B" + assert maple_code(B * A) == "B.A" + assert maple_code(2 * A * B) == "2A.B" + assert maple_code(B 2 * A) == "2B.A" + + assert maple_code( + A (B + 3 * Identity(n))) == "A.(3Matrix(n, shape = identity) + B)" + + assert maple_code(A * (x 2)) == "MatrixPower(A, x^2)" + assert maple_code(A 3) == "MatrixPower(A, 3)" + assert maple_code(A ** (S.Half)) == "MatrixPower(A, 1/2)" + + +def test_special_matrices(): + assert maple_code(6 * Identity(3)) == "6Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], storage = sparse)" + assert maple_code(Identity(x)) == 'Matrix(x, shape = identity)' + + +def test_containers(): + assert maple_code([1, 2, 3, [4, 5, [6, 7]], 8, [9, 10], 11]) == \ + "[1, 2, 3, [4, 5, [6, 7]], 8, [9, 10], 11]" + + assert maple_code((1, 2, (3, 4))) == "[1, 2, [3, 4]]" + assert maple_code([1]) == "[1]" + assert maple_code((1,)) == "[1]" + assert maple_code(Tuple([1, 2, 3])) == "[1, 2, 3]" + assert maple_code((1, x * y, (3, x ** 2))) == "[1, xy, [3, x^2]]" + # scalar, matrix, empty matrix and empty list + + assert maple_code((1, eye(3), Matrix(0, 0, []), [])) == \ + "[1, Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], storage = rectangular), Matrix([], storage = rectangular), []]" + + +def test_maple_noninline(): + source = maple_code((x + y)/Catalan, assign_to='me', inline=False) + expected = "me := (x + y)/Catalan" + + assert source == expected + + +def test_maple_matrix_assign_to(): + A = Matrix([[1, 2, 3]]) + assert maple_code(A, assign_to='a') == "a := Matrix([[1, 2, 3]], storage = rectangular)" + A = Matrix([[1, 2], [3, 4]]) + assert maple_code(A, assign_to='A') == "A := Matrix([[1, 2], [3, 4]], storage = rectangular)" + + +def test_maple_matrix_assign_to_more(): + # assigning to Symbol or MatrixSymbol requires lhs/rhs match + A = Matrix([[1, 2, 3]]) + B = MatrixSymbol('B', 1, 3) + C = MatrixSymbol('C', 2, 3) + assert maple_code(A, assign_to=B) == "B := Matrix([[1, 2, 3]], storage = rectangular)" + raises(ValueError, lambda: maple_code(A, assign_to=x)) + raises(ValueError, lambda: maple_code(A, assign_to=C)) + + +def test_maple_matrix_1x1(): + A = Matrix([[3]]) + assert maple_code(A, assign_to='B') == "B := Matrix([[3]], storage = rectangular)" + + +def test_maple_matrix_elements(): + A = Matrix([[x, 2, x y]]) + + assert maple_code(A[0, 0] ** 2 + A[0, 1] + A[0, 2]) == "x^2 + xy + 2" + AA = MatrixSymbol('AA', 1, 3) + assert maple_code(AA) == "AA" + + assert maple_code(AA[0, 0] * 2 + sin(AA[0, 1]) + AA[0, 2]) == \ + "sin(AA[1, 2]) + AA[1, 1]^2 + AA[1, 3]" + assert maple_code(sum(AA)) == "AA[1, 1] + AA[1, 2] + AA[1, 3]" + + +def test_maple_boolean(): + assert maple_code(True) == "true" + assert maple_code(S.true) == "true" + assert maple_code(False) == "false" + assert maple_code(S.false) == "false" + + +def test_sparse(): + M = SparseMatrix(5, 6, {}) + M[2, 2] = 10 + M[1, 2] = 20 + M[1, 3] = 22 + M[0, 3] = 30 + M[3, 0] = x * y + assert maple_code(M) == \ + 'Matrix([[0, 0, 0, 30, 0, 0],' \ + ' [0, 0, 20, 22, 0, 0],' \ + ' [0, 0, 10, 0, 0, 0],' \ + ' [xy, 0, 0, 0, 0, 0],' \ + ' [0, 0, 0, 0, 0, 0]], ' \ + 'storage = sparse)' + +# Not an important point. +def test_maple_not_supported(): + assert maple_code(S.ComplexInfinity) == ( + "# Not supported in maple:\n" + "# ComplexInfinity\n" + "zoo" + ) # PROBLEM + + + +def test_MatrixElement_printing(): + # test cases for issue #11821 + A = MatrixSymbol("A", 1, 3) + B = MatrixSymbol("B", 1, 3) + C = MatrixSymbol("C", 1, 3) + + assert (maple_code(A[0, 0]) == "A[1, 1]") + assert (maple_code(3 A[0, 0]) == "3A[1, 1]") + + F = A-B + + assert (maple_code(F[0,0]) == "A[1, 1] - B[1, 1]") + + +def test_hadamard(): + A = MatrixSymbol('A', 3, 3) + B = MatrixSymbol('B', 3, 3) + v = MatrixSymbol('v', 3, 1) + h = MatrixSymbol('h', 1, 3) + C = HadamardProduct(A, B) + assert maple_code(C) == "AB" + + assert maple_code(C * v) == "(AB).v" + # HadamardProduct is higher than dot product. + + assert maple_code(h C * v) == "h.(AB).v" + + assert maple_code(C A) == "(AB).A" + # mixing Hadamard and scalar strange b/c we vectorize scalars + + assert maple_code(C x * y) == "xy(AB)" + + +def test_maple_piecewise(): + expr = Piecewise((x, x < 1), (x * 2, True)) + + assert maple_code(expr) == "piecewise(x < 1, x, x^2)" + assert maple_code(expr, assign_to="r") == ( + "r := piecewise(x < 1, x, x^2)") + + expr = Piecewise((x 2, x < 1), (x 3, x < 2), (x 4, x < 3), (x 5, True)) + expected = "piecewise(x < 1, x^2, x < 2, x^3, x < 3, x^4, x^5)" + assert maple_code(expr) == expected + assert maple_code(expr, assign_to="r") == "r := " + expected + + # Check that Piecewise without a True (default) condition error + expr = Piecewise((x, x < 1), (x 2, x > 1), (sin(x), x > 0)) + raises(ValueError, lambda: maple_code(expr)) + + +def test_maple_piecewise_times_const(): + pw = Piecewise((x, x < 1), (x 2, True)) + + assert maple_code(2 * pw) == "2piecewise(x < 1, x, x^2)" + assert maple_code(pw / x) == "piecewise(x < 1, x, x^2)/x" + assert maple_code(pw / (x y)) == "piecewise(x < 1, x, x^2)/(xy)" + assert maple_code(pw / 3) == "(1/3)piecewise(x < 1, x, x^2)" + + +def test_maple_derivatives(): + f = Function('f') + assert maple_code(f(x).diff(x)) == 'diff(f(x), x)' + assert maple_code(f(x).diff(x, 2)) == 'diff(f(x), x$2)' + + +def test_specfun(): + assert maple_code('asin(x)') == 'arcsin(x)' + assert maple_code(besseli(x, y)) == 'BesselI(x, y)'	diff --git a/.gitignore b/.gitignore index 2614e1546e15..db4a22815e50 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,8 @@ # track a file that is ignored for some reason, you have to use # "git add -f". See "git help gitignore" for more information. +# Virtualenv +/.venv/ # Regular Python bytecode file *.pyc diff --git a/doc/src/modules/printing.rst b/doc/src/modules/printing.rst index 2adf23a024cb..4729ed9a25b6 100644 --- a/doc/src/modules/printing.rst +++ b/doc/src/modules/printing.rst @@ -301,6 +301,20 @@ Mathematica code printing .. autofunction:: sympy.printing.mathematica.mathematica_code +Maple code printing +------------------- + +.. module:: sympy.printing.maple + +.. autoclass:: sympy.printing.maple.MapleCodePrinter + :members: + + .. autoattribute:: MapleCodePrinter.printmethod + +.. autofunction:: sympy.printing.maple.maple_code + +.. autofunction:: sympy.printing.maple.print_maple_code + Javascript Code printing ------------------------	[ { "components": [ { "doc": "Printer which converts a sympy expression into a maple code.", "lines": [ 77, 262 ], "name": "MapleCodePrinter", "signature": "class MapleCodePrinter(CodePrinter):", "type": "class" }, { "do...	[ "test_Integer", "test_Rational", "test_Relational", "test_Function", "test_Pow", "test_basic_ops", "test_1_over_x_and_sqrt", "test_mix_number_mult_symbols", "test_mix_number_pow_symbols", "test_imag", "test_constants", "test_constants_other", "test_boolean", "test_Matrices", "test_Sparse...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add maple code printer <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> The development is not finished. But the overall structure established. Please give me some feedback for this. #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed Add a maple code printer. #### Other comments Still under development. #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * printing * Added a Maple code printer. <!-- END RELEASE NOTES --> <!-- BEGIN RELEASE NOTES --> <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/printing/maple.py] (definition of MapleCodePrinter:) class MapleCodePrinter(CodePrinter): """Printer which converts a sympy expression into a maple code.""" (definition of MapleCodePrinter.__init__:) def __init__(self, settings=None): (definition of MapleCodePrinter._get_statement:) def _get_statement(self, codestring): (definition of MapleCodePrinter._get_comment:) def _get_comment(self, text): (definition of MapleCodePrinter._declare_number_const:) def _declare_number_const(self, name, value): (definition of MapleCodePrinter._format_code:) def _format_code(self, lines): (definition of MapleCodePrinter._print_tuple:) def _print_tuple(self, expr): (definition of MapleCodePrinter._print_Tuple:) def _print_Tuple(self, expr): (definition of MapleCodePrinter._print_Assignment:) def _print_Assignment(self, expr): (definition of MapleCodePrinter._print_Pow:) def _print_Pow(self, expr, kwargs): (definition of MapleCodePrinter._print_Piecewise:) def _print_Piecewise(self, expr): (definition of MapleCodePrinter._print_Rational:) def _print_Rational(self, expr): (definition of MapleCodePrinter._print_Relational:) def _print_Relational(self, expr): (definition of MapleCodePrinter._print_NumberSymbol:) def _print_NumberSymbol(self, expr): (definition of MapleCodePrinter._print_NegativeInfinity:) def _print_NegativeInfinity(self, expr): (definition of MapleCodePrinter._print_Infinity:) def _print_Infinity(self, expr): (definition of MapleCodePrinter._print_Idx:) def _print_Idx(self, expr): (definition of MapleCodePrinter._print_BooleanTrue:) def _print_BooleanTrue(self, expr): (definition of MapleCodePrinter._print_BooleanFalse:) def _print_BooleanFalse(self, expr): (definition of MapleCodePrinter._print_bool:) def _print_bool(self, expr): (definition of MapleCodePrinter._print_NaN:) def _print_NaN(self, expr): (definition of MapleCodePrinter._get_matrix:) def _get_matrix(self, expr, sparse=False): (definition of MapleCodePrinter._print_MatrixElement:) def _print_MatrixElement(self, expr): (definition of MapleCodePrinter._print_MatrixBase:) def _print_MatrixBase(self, expr): (definition of MapleCodePrinter._print_SparseMatrix:) def _print_SparseMatrix(self, expr): (definition of MapleCodePrinter._print_Identity:) def _print_Identity(self, expr): (definition of MapleCodePrinter._print_MatMul:) def _print_MatMul(self, expr): (definition of MapleCodePrinter._print_MatPow:) def _print_MatPow(self, expr): (definition of MapleCodePrinter._print_HadamardProduct:) def _print_HadamardProduct(self, expr): (definition of MapleCodePrinter._print_Derivative:) def _print_Derivative(self, expr): (definition of maple_code:) def maple_code(expr, assign_to=None, settings): """Converts ``expr`` to a string of Maple code. Parameters ========== expr : Expr A sympy expression to be converted. assign_to : optional When given, the argument is used as the name of the variable to which the expression is assigned. Can be a string, ``Symbol``, ``MatrixSymbol``, or ``Indexed`` type. This can be helpful for expressions that generate multi-line statements. precision : integer, optional The precision for numbers such as pi [default=16]. user_functions : dict, optional A dictionary where keys are ``FunctionClass`` instances and values are their string representations. Alternatively, the dictionary value can be a list of tuples i.e. [(argument_test, cfunction_string)]. See below for examples. human : bool, optional If True, the result is a single string that may contain some constant declarations for the number symbols. If False, the same information is returned in a tuple of (symbols_to_declare, not_supported_functions, code_text). [default=True]. contract: bool, optional If True, ``Indexed`` instances are assumed to obey tensor contraction rules and the corresponding nested loops over indices are generated. Setting contract=False will not generate loops, instead the user is responsible to provide values for the indices in the code. [default=True]. inline: bool, optional If True, we try to create single-statement code instead of multiple statements. [default=True].""" (definition of print_maple_code:) def print_maple_code(expr, **settings): """Prints the Maple representation of the given expression. See :func:`maple_code` for the meaning of the optional arguments. Examples ======== >>> from sympy.printing.maple import print_maple_code >>> from sympy import symbols >>> x, y = symbols('x y') >>> print_maple_code(x, assign_to=y) y := x""" [end of new definitions in sympy/printing/maple.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-17239	17,239	sympy/sympy	1.5	8a375578647590e16aff119a2363a12ff171306c	2019-07-21T14:32:26Z	diff --git a/sympy/printing/ccode.py b/sympy/printing/ccode.py index 0aa125278d02..8ee46a3bfd19 100644 --- a/sympy/printing/ccode.py +++ b/sympy/printing/ccode.py @@ -390,7 +390,7 @@ def _print_Relational(self, expr): lhs_code = self._print(expr.lhs) rhs_code = self._print(expr.rhs) op = expr.rel_op - return ("{0} {1} {2}").format(lhs_code, op, rhs_code) + return "{0} {1} {2}".format(lhs_code, op, rhs_code) def _print_sinc(self, expr): from sympy.functions.elementary.trigonometric import sin diff --git a/sympy/printing/codeprinter.py b/sympy/printing/codeprinter.py index 7dd729560803..fb9caa35e4e9 100644 --- a/sympy/printing/codeprinter.py +++ b/sympy/printing/codeprinter.py @@ -532,3 +532,4 @@ def _print_not_supported(self, expr): _print_Unit = _print_not_supported _print_Wild = _print_not_supported _print_WildFunction = _print_not_supported + _print_Relational = _print_not_supported diff --git a/sympy/printing/fcode.py b/sympy/printing/fcode.py index 9b3cb0727922..4648ba8da8e7 100644 --- a/sympy/printing/fcode.py +++ b/sympy/printing/fcode.py @@ -365,6 +365,13 @@ def _print_Float(self, expr): return "%sd%s" % (printed[:e], printed[e + 1:]) return "%sd0" % printed + def _print_Relational(self, expr): + lhs_code = self._print(expr.lhs) + rhs_code = self._print(expr.rhs) + op = expr.rel_op + op = op if op not in self._relationals else self._relationals[op] + return "{0} {1} {2}".format(lhs_code, op, rhs_code) + def _print_Indexed(self, expr): inds = [ self._print(i) for i in expr.indices ] return "%s(%s)" % (self._print(expr.base.label), ", ".join(inds)) @@ -425,14 +432,6 @@ def _print_For(self, expr): 'end do').format(target=target, start=start, stop=stop, step=step, body=body) - def _print_Equality(self, expr): - lhs, rhs = expr.args - return ' == '.join(map(lambda arg: self._print(arg), (lhs, rhs))) - - def _print_Unequality(self, expr): - lhs, rhs = expr.args - return ' /= '.join(map(lambda arg: self._print(arg), (lhs, rhs))) - def _print_Type(self, type_): type_ = self.type_aliases.get(type_, type_) type_str = self.type_mappings.get(type_, type_.name) diff --git a/sympy/printing/glsl.py b/sympy/printing/glsl.py index db8e6694cdd7..d04c49fe5c67 100644 --- a/sympy/printing/glsl.py +++ b/sympy/printing/glsl.py @@ -281,6 +281,12 @@ def _print_int(self, expr): def _print_Rational(self, expr): return "%s.0/%s.0" % (expr.p, expr.q) + def _print_Relational(self, expr): + lhs_code = self._print(expr.lhs) + rhs_code = self._print(expr.rhs) + op = expr.rel_op + return "{0} {1} {2}".format(lhs_code, op, rhs_code) + def _print_Add(self, expr, order=None): if self._settings['use_operators']: return CodePrinter._print_Add(self, expr, order=order) diff --git a/sympy/printing/jscode.py b/sympy/printing/jscode.py index 6f456e45fd6a..2e77de3f38dd 100644 --- a/sympy/printing/jscode.py +++ b/sympy/printing/jscode.py @@ -113,6 +113,12 @@ def _print_Rational(self, expr): p, q = int(expr.p), int(expr.q) return '%d/%d' % (p, q) + def _print_Relational(self, expr): + lhs_code = self._print(expr.lhs) + rhs_code = self._print(expr.rhs) + op = expr.rel_op + return "{0} {1} {2}".format(lhs_code, op, rhs_code) + def _print_Indexed(self, expr): # calculate index for 1d array dims = expr.shape diff --git a/sympy/printing/julia.py b/sympy/printing/julia.py index b0a75b94b377..973ee56736f1 100644 --- a/sympy/printing/julia.py +++ b/sympy/printing/julia.py @@ -190,6 +190,11 @@ def multjoin(a, a_str): return (sign + multjoin(a, a_str) + divsym + "(%s)" % multjoin(b, b_str)) + def _print_Relational(self, expr): + lhs_code = self._print(expr.lhs) + rhs_code = self._print(expr.rhs) + op = expr.rel_op + return "{0} {1} {2}".format(lhs_code, op, rhs_code) def _print_Pow(self, expr): powsymbol = '^' if all([x.is_number for x in expr.args]) else '.^' diff --git a/sympy/printing/mathematica.py b/sympy/printing/mathematica.py index 9ee83f13fde9..0ffb0f137713 100644 --- a/sympy/printing/mathematica.py +++ b/sympy/printing/mathematica.py @@ -157,6 +157,11 @@ def _print_Mul(self, expr): res += '**'.join(self.parenthesize(a, PREC) for a in nc) return res + def _print_Relational(self, expr): + lhs_code = self._print(expr.lhs) + rhs_code = self._print(expr.rhs) + op = expr.rel_op + return "{0} {1} {2}".format(lhs_code, op, rhs_code) # Primitive numbers def _print_Zero(self, expr): diff --git a/sympy/printing/octave.py b/sympy/printing/octave.py index 684431e19b2f..e76e5cc44575 100644 --- a/sympy/printing/octave.py +++ b/sympy/printing/octave.py @@ -209,6 +209,11 @@ def multjoin(a, a_str): return (sign + multjoin(a, a_str) + divsym + "(%s)" % multjoin(b, b_str)) + def _print_Relational(self, expr): + lhs_code = self._print(expr.lhs) + rhs_code = self._print(expr.rhs) + op = expr.rel_op + return "{0} {1} {2}".format(lhs_code, op, rhs_code) def _print_Pow(self, expr): powsymbol = '^' if all([x.is_number for x in expr.args]) else '.^' diff --git a/sympy/printing/rcode.py b/sympy/printing/rcode.py index 11a78a8be39d..11e02d34dc08 100644 --- a/sympy/printing/rcode.py +++ b/sympy/printing/rcode.py @@ -246,7 +246,7 @@ def _print_Relational(self, expr): lhs_code = self._print(expr.lhs) rhs_code = self._print(expr.rhs) op = expr.rel_op - return ("{0} {1} {2}").format(lhs_code, op, rhs_code) + return "{0} {1} {2}".format(lhs_code, op, rhs_code) def _print_sinc(self, expr): from sympy.functions.elementary.trigonometric import sin diff --git a/sympy/printing/rust.py b/sympy/printing/rust.py index 5ccb50819156..5edb5b4301c8 100644 --- a/sympy/printing/rust.py +++ b/sympy/printing/rust.py @@ -358,6 +358,12 @@ def _print_Rational(self, expr): p, q = int(expr.p), int(expr.q) return '%d_f64/%d.0' % (p, q) + def _print_Relational(self, expr): + lhs_code = self._print(expr.lhs) + rhs_code = self._print(expr.rhs) + op = expr.rel_op + return "{0} {1} {2}".format(lhs_code, op, rhs_code) + def _print_Indexed(self, expr): # calculate index for 1d array dims = expr.shape	diff --git a/sympy/printing/tests/test_glsl.py b/sympy/printing/tests/test_glsl.py index 76ab05be2293..53a39d2595cb 100644 --- a/sympy/printing/tests/test_glsl.py +++ b/sympy/printing/tests/test_glsl.py @@ -1,4 +1,5 @@ -from sympy.core import pi, oo, symbols, Rational, Integer, GoldenRatio, EulerGamma, Catalan, Lambda, Dummy +from sympy.core import (pi, symbols, Rational, Integer, GoldenRatio, EulerGamma, + Catalan, Lambda, Dummy, Eq, Ne, Le, Lt, Gt, Ge) from sympy.functions import Piecewise, sin, cos, Abs, exp, ceiling, sqrt from sympy.utilities.pytest import raises from sympy.printing.glsl import GLSLPrinter @@ -37,6 +38,15 @@ def test_glsl_code_Pow(): assert glsl_code(x*-1.0) == '1.0/x' +def test_glsl_code_Relational(): + assert glsl_code(Eq(x, y)) == "x == y" + assert glsl_code(Ne(x, y)) == "x != y" + assert glsl_code(Le(x, y)) == "x <= y" + assert glsl_code(Lt(x, y)) == "x < y" + assert glsl_code(Gt(x, y)) == "x > y" + assert glsl_code(Ge(x, y)) == "x >= y" + + def test_glsl_code_constants_mathh(): assert glsl_code(exp(1)) == "float E = 2.71828183;\nE" assert glsl_code(pi) == "float pi = 3.14159265;\npi" diff --git a/sympy/printing/tests/test_jscode.py b/sympy/printing/tests/test_jscode.py index ff228d2a1206..6b24c98adfd0 100644 --- a/sympy/printing/tests/test_jscode.py +++ b/sympy/printing/tests/test_jscode.py @@ -1,5 +1,6 @@ from sympy.core import (pi, oo, symbols, Rational, Integer, GoldenRatio, - EulerGamma, Catalan, Lambda, Dummy, S) + EulerGamma, Catalan, Lambda, Dummy, S, Eq, Ne, Le, + Lt, Gt, Ge) from sympy.functions import (Piecewise, sin, cos, Abs, exp, ceiling, sqrt, sinh, cosh, tanh, asin, acos, acosh, Max, Min) from sympy.utilities.pytest import raises @@ -54,6 +55,16 @@ def test_jscode_Rational(): assert jscode(Rational(-3, -7)) == "3/7" +def test_Relational(): + assert jscode(Eq(x, y)) == "x == y" + assert jscode(Ne(x, y)) == "x != y" + assert jscode(Le(x, y)) == "x <= y" + assert jscode(Lt(x, y)) == "x < y" + assert jscode(Gt(x, y)) == "x > y" + assert jscode(Ge(x, y)) == "x >= y" + + + def test_jscode_Integer(): assert jscode(Integer(67)) == "67" assert jscode(Integer(-1)) == "-1" diff --git a/sympy/printing/tests/test_julia.py b/sympy/printing/tests/test_julia.py index 4aea0db1fc4d..26cf9419b6a5 100644 --- a/sympy/printing/tests/test_julia.py +++ b/sympy/printing/tests/test_julia.py @@ -1,5 +1,5 @@ from sympy.core import (S, pi, oo, symbols, Function, Rational, Integer, - Tuple, Symbol) + Tuple, Symbol, Eq, Ne, Le, Lt, Gt, Ge) from sympy.core import EulerGamma, GoldenRatio, Catalan, Lambda, Mul, Pow from sympy.functions import Piecewise, sqrt, ceiling, exp, sin, cos from sympy.utilities.pytest import raises @@ -10,7 +10,6 @@ besselk, hankel1, hankel2, airyai, airybi, airyaiprime, airybiprime) from sympy.utilities.pytest import XFAIL -from sympy.core.compatibility import range from sympy import julia_code @@ -31,6 +30,15 @@ def test_Rational(): assert julia_code(Rational(3, 7)x) == "3x/7" +def test_Relational(): + assert julia_code(Eq(x, y)) == "x == y" + assert julia_code(Ne(x, y)) == "x != y" + assert julia_code(Le(x, y)) == "x <= y" + assert julia_code(Lt(x, y)) == "x < y" + assert julia_code(Gt(x, y)) == "x > y" + assert julia_code(Ge(x, y)) == "x >= y" + + def test_Function(): assert julia_code(sin(x) * cos(x)) == "sin(x).^cos(x)" assert julia_code(abs(x)) == "abs(x)" diff --git a/sympy/printing/tests/test_mathematica.py b/sympy/printing/tests/test_mathematica.py index 787df1af45d7..a2aa5cc16afe 100644 --- a/sympy/printing/tests/test_mathematica.py +++ b/sympy/printing/tests/test_mathematica.py @@ -1,5 +1,5 @@ -from sympy.core import (S, pi, oo, symbols, Function, - Rational, Integer, Tuple, Derivative) +from sympy.core import (S, pi, oo, symbols, Function, Rational, Integer, Tuple, + Derivative, Eq, Ne, Le, Lt, Gt, Ge) from sympy.integrals import Integral from sympy.concrete import Sum from sympy.functions import (exp, sin, cos, fresnelc, fresnels, conjugate, Max, @@ -32,6 +32,15 @@ def test_Rational(): assert mcode(Rational(3, 7)x) == "(3/7)x" +def test_Relational(): + assert mcode(Eq(x, y)) == "x == y" + assert mcode(Ne(x, y)) == "x != y" + assert mcode(Le(x, y)) == "x <= y" + assert mcode(Lt(x, y)) == "x < y" + assert mcode(Gt(x, y)) == "x > y" + assert mcode(Ge(x, y)) == "x >= y" + + def test_Function(): assert mcode(f(x, y, z)) == "f[x, y, z]" assert mcode(sin(x) ** cos(x)) == "Sin[x]^Cos[x]" diff --git a/sympy/printing/tests/test_octave.py b/sympy/printing/tests/test_octave.py index a56c68158379..df3b695110d8 100644 --- a/sympy/printing/tests/test_octave.py +++ b/sympy/printing/tests/test_octave.py @@ -1,6 +1,6 @@ from sympy.core import (S, pi, oo, symbols, Function, Rational, Integer, Tuple, Symbol, EulerGamma, GoldenRatio, Catalan, - Lambda, Mul, Pow, Mod) + Lambda, Mul, Pow, Mod, Eq, Ne, Le, Lt, Gt, Ge) from sympy.codegen.matrix_nodes import MatrixSolve from sympy.functions import (arg, atan2, bernoulli, beta, ceiling, chebyshevu, chebyshevt, conjugate, DiracDelta, exp, expint, @@ -25,10 +25,6 @@ erfcinv, erfinv, fresnelc, fresnels, li, Shi, Si, Li, erf2) -from sympy.polys.polytools import gcd, lcm -from sympy.ntheory.primetest import isprime -from sympy.core.compatibility import range - from sympy import octave_code from sympy import octave_code as mcode @@ -49,6 +45,15 @@ def test_Rational(): assert mcode(Rational(3, 7)x) == "3x/7" +def test_Relational(): + assert mcode(Eq(x, y)) == "x == y" + assert mcode(Ne(x, y)) == "x != y" + assert mcode(Le(x, y)) == "x <= y" + assert mcode(Lt(x, y)) == "x < y" + assert mcode(Gt(x, y)) == "x > y" + assert mcode(Ge(x, y)) == "x >= y" + + def test_Function(): assert mcode(sin(x) ** cos(x)) == "sin(x).^cos(x)" assert mcode(sign(x)) == "sign(x)" diff --git a/sympy/printing/tests/test_rust.py b/sympy/printing/tests/test_rust.py index 2e1a5d8c029d..afa0d48374cb 100644 --- a/sympy/printing/tests/test_rust.py +++ b/sympy/printing/tests/test_rust.py @@ -1,13 +1,12 @@ from sympy.core import (S, pi, oo, symbols, Rational, Integer, - GoldenRatio, EulerGamma, Catalan, Lambda, Dummy, Eq) + GoldenRatio, EulerGamma, Catalan, Lambda, Dummy, + Eq, Ne, Le, Lt, Gt, Ge) from sympy.functions import (Piecewise, sin, cos, Abs, exp, ceiling, sqrt, - gamma, sign) + sign) from sympy.logic import ITE from sympy.utilities.pytest import raises -from sympy.printing.rust import RustCodePrinter from sympy.utilities.lambdify import implemented_function from sympy.tensor import IndexedBase, Idx -from sympy.matrices import Matrix, MatrixSymbol from sympy import rust_code @@ -19,6 +18,15 @@ def test_Integer(): assert rust_code(Integer(-56)) == "-56" +def test_Relational(): + assert rust_code(Eq(x, y)) == "x == y" + assert rust_code(Ne(x, y)) == "x != y" + assert rust_code(Le(x, y)) == "x <= y" + assert rust_code(Lt(x, y)) == "x < y" + assert rust_code(Gt(x, y)) == "x > y" + assert rust_code(Ge(x, y)) == "x >= y" + + def test_Rational(): assert rust_code(Rational(3, 7)) == "3_f64/7.0" assert rust_code(Rational(18, 9)) == "2"		[ { "components": [ { "doc": "", "lines": [ 368, 373 ], "name": "FCodePrinter._print_Relational", "signature": "def _print_Relational(self, expr):", "type": "function" } ], "file": "sympy/printing/fcode.py" }, { "compo...	[ "test_glsl_code_Relational", "test_Relational" ]	[ "test_printmethod", "test_print_without_operators", "test_glsl_code_sqrt", "test_glsl_code_Pow", "test_glsl_code_constants_mathh", "test_glsl_code_constants_other", "test_glsl_code_Rational", "test_glsl_code_Integer", "test_glsl_code_functions", "test_glsl_code_inline_function", "test_glsl_code_...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added relational operator printer for various languages <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> Fixes #17238 #### Brief description of what is fixed or changed Added relational operator printer for following languages: 1. glsl 2. js 3. julia 4. mathematica 5. octave 6. rust I have also verified that they are correct. Added tests for same. Ping @sylee957 #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - printing - added relational operator printing for various languages <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/printing/fcode.py] (definition of FCodePrinter._print_Relational:) def _print_Relational(self, expr): [end of new definitions in sympy/printing/fcode.py] [start of new definitions in sympy/printing/glsl.py] (definition of GLSLPrinter._print_Relational:) def _print_Relational(self, expr): [end of new definitions in sympy/printing/glsl.py] [start of new definitions in sympy/printing/jscode.py] (definition of JavascriptCodePrinter._print_Relational:) def _print_Relational(self, expr): [end of new definitions in sympy/printing/jscode.py] [start of new definitions in sympy/printing/julia.py] (definition of JuliaCodePrinter._print_Relational:) def _print_Relational(self, expr): [end of new definitions in sympy/printing/julia.py] [start of new definitions in sympy/printing/mathematica.py] (definition of MCodePrinter._print_Relational:) def _print_Relational(self, expr): [end of new definitions in sympy/printing/mathematica.py] [start of new definitions in sympy/printing/octave.py] (definition of OctaveCodePrinter._print_Relational:) def _print_Relational(self, expr): [end of new definitions in sympy/printing/octave.py] [start of new definitions in sympy/printing/rust.py] (definition of RustCodePrinter._print_Relational:) def _print_Relational(self, expr): [end of new definitions in sympy/printing/rust.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Relational printing ```python3 from sympy import * from sympy.printing.ccode import ccode from sympy.printing.cxxcode import cxxcode from sympy.printing.fcode import fcode from sympy.printing.glsl import glsl_code from sympy.printing.jscode import jscode from sympy.printing.julia import julia_code from sympy.printing.mathematica import mathematica_code from sympy.printing.octave import octave_code from sympy.printing.pycode import pycode from sympy.printing.rcode import rcode from sympy.printing.rust import rust_code x = Symbol('x') print(ccode(Eq(x, 1))) print(cxxcode(Eq(x, 1))) print(glsl_code(Eq(x, 1))) print(fcode(Eq(x, 1))) print(jscode(Eq(x, 1))) print(julia_code(Eq(x, 1))) print(mathematica_code(Eq(x, 1))) print(octave_code(Eq(x, 1))) print(pycode(Eq(x, 1))) print(rcode(Eq(x, 1))) print(rust_code(Eq(x, 1))) ``` Result ``` x == 1 x == 1 Eq(x, 1) x == 1 Eq(x, 1) Eq(x, 1) Eq(x, 1) Eq(x, 1) (x == 1) x == 1 Eq(x, 1) ``` glsl, javascript, julia, mathematica, octave, rust code printers are probably printing equality in a wrong way. They are false-positively looking up for `StrPrinter._print_Relational` C or Fortran printers are overriding `_print_Relational`, so they are the only things working. ---------- -------------------- </issues>	c72f122f67553e1af930bac6c35732d2a0bbb776
scikit-learn__scikit-learn-14307	14,307	scikit-learn/scikit-learn	0.22	bf8eff3feaded1464e81dcc0c4b7f9a3975c014f	2019-07-12T09:47:52Z	diff --git a/sklearn/cluster/k_means_.py b/sklearn/cluster/k_means_.py index 8f8d8f66c405e..33815b2c177f0 100644 --- a/sklearn/cluster/k_means_.py +++ b/sklearn/cluster/k_means_.py @@ -27,7 +27,7 @@ from ..utils import check_array from ..utils import gen_batches from ..utils import check_random_state -from ..utils.validation import check_is_fitted +from ..utils.validation import check_is_fitted, _check_sample_weight from ..utils.validation import FLOAT_DTYPES from ..exceptions import ConvergenceWarning from . import _k_means @@ -164,19 +164,19 @@ def _tolerance(X, tol): return np.mean(variances) * tol -def _check_sample_weight(X, sample_weight): +def _check_normalize_sample_weight(sample_weight, X): """Set sample_weight if None, and check for correct dtype""" - n_samples = X.shape[0] - if sample_weight is None: - return np.ones(n_samples, dtype=X.dtype) - else: - sample_weight = np.asarray(sample_weight) - if n_samples != len(sample_weight): - raise ValueError("n_samples=%d should be == len(sample_weight)=%d" - % (n_samples, len(sample_weight))) + + sample_weight_was_none = sample_weight is None + + sample_weight = _check_sample_weight(sample_weight, X, dtype=X.dtype) + if not sample_weight_was_none: # normalize the weights to sum up to n_samples + # an array of 1 (i.e. samples_weight is None) is already normalized + n_samples = len(sample_weight) scale = n_samples / sample_weight.sum() - return (sample_weight * scale).astype(X.dtype, copy=False) + sample_weight *= scale + return sample_weight def k_means(X, n_clusters, sample_weight=None, init='k-means++', @@ -434,7 +434,7 @@ def _kmeans_single_elkan(X, sample_weight, n_clusters, max_iter=300, if verbose: print('Initialization complete') - checked_sample_weight = _check_sample_weight(X, sample_weight) + checked_sample_weight = _check_normalize_sample_weight(sample_weight, X) centers, labels, n_iter = k_means_elkan(X, checked_sample_weight, n_clusters, centers, tol=tol, max_iter=max_iter, verbose=verbose) @@ -519,7 +519,7 @@ def _kmeans_single_lloyd(X, sample_weight, n_clusters, max_iter=300, """ random_state = check_random_state(random_state) - sample_weight = _check_sample_weight(X, sample_weight) + sample_weight = _check_normalize_sample_weight(sample_weight, X) best_labels, best_inertia, best_centers = None, None, None # init @@ -662,7 +662,7 @@ def _labels_inertia(X, sample_weight, x_squared_norms, centers, Sum of squared distances of samples to their closest cluster center. """ n_samples = X.shape[0] - sample_weight = _check_sample_weight(X, sample_weight) + sample_weight = _check_normalize_sample_weight(sample_weight, X) # set the default value of centers to -1 to be able to detect any anomaly # easily labels = np.full(n_samples, -1, np.int32) @@ -1492,7 +1492,7 @@ def fit(self, X, y=None, sample_weight=None): raise ValueError("n_samples=%d should be >= n_clusters=%d" % (n_samples, self.n_clusters)) - sample_weight = _check_sample_weight(X, sample_weight) + sample_weight = _check_normalize_sample_weight(sample_weight, X) n_init = self.n_init if hasattr(self.init, '__array__'): @@ -1641,7 +1641,7 @@ def _labels_inertia_minibatch(self, X, sample_weight): """ if self.verbose: print('Computing label assignment and total inertia') - sample_weight = _check_sample_weight(X, sample_weight) + sample_weight = _check_normalize_sample_weight(sample_weight, X) x_squared_norms = row_norms(X, squared=True) slices = gen_batches(X.shape[0], self.batch_size) results = [_labels_inertia(X[s], sample_weight[s], x_squared_norms[s], @@ -1676,7 +1676,7 @@ def partial_fit(self, X, y=None, sample_weight=None): if n_samples == 0: return self - sample_weight = _check_sample_weight(X, sample_weight) + sample_weight = _check_normalize_sample_weight(sample_weight, X) x_squared_norms = row_norms(X, squared=True) self.random_state_ = getattr(self, "random_state_", diff --git a/sklearn/linear_model/huber.py b/sklearn/linear_model/huber.py index 8664f3edb94dc..e518feae29b78 100644 --- a/sklearn/linear_model/huber.py +++ b/sklearn/linear_model/huber.py @@ -8,8 +8,8 @@ from ..base import BaseEstimator, RegressorMixin from .base import LinearModel from ..utils import check_X_y -from ..utils import check_consistent_length from ..utils import axis0_safe_slice +from ..utils.validation import _check_sample_weight from ..utils.extmath import safe_sparse_dot from ..utils.optimize import _check_optimize_result @@ -255,11 +255,8 @@ def fit(self, X, y, sample_weight=None): X, y = check_X_y( X, y, copy=False, accept_sparse=['csr'], y_numeric=True, dtype=[np.float64, np.float32]) - if sample_weight is not None: - sample_weight = np.array(sample_weight) - check_consistent_length(y, sample_weight) - else: - sample_weight = np.ones_like(y) + + sample_weight = _check_sample_weight(sample_weight, X) if self.epsilon < 1.0: raise ValueError( diff --git a/sklearn/linear_model/logistic.py b/sklearn/linear_model/logistic.py index decd345a9bdbb..10a4d32e51275 100644 --- a/sklearn/linear_model/logistic.py +++ b/sklearn/linear_model/logistic.py @@ -30,7 +30,7 @@ from ..utils.fixes import logsumexp from ..utils.optimize import newton_cg, _check_optimize_result from ..utils.validation import check_X_y -from ..utils.validation import check_is_fitted +from ..utils.validation import check_is_fitted, _check_sample_weight from ..utils import deprecated from ..exceptions import ChangedBehaviorWarning from ..utils.multiclass import check_classification_targets @@ -826,11 +826,8 @@ def _logistic_regression_path(X, y, pos_class=None, Cs=10, fit_intercept=True, # If sample weights exist, convert them to array (support for lists) # and check length # Otherwise set them to 1 for all examples - if sample_weight is not None: - sample_weight = np.array(sample_weight, dtype=X.dtype, order='C') - check_consistent_length(y, sample_weight) - else: - sample_weight = np.ones(X.shape[0], dtype=X.dtype) + sample_weight = _check_sample_weight(sample_weight, X, + dtype=X.dtype) # If class_weights is a dict (provided by the user), the weights # are assigned to the original labels. If it is "balanced", then @@ -1133,9 +1130,7 @@ def _log_reg_scoring_path(X, y, train, test, pos_class=None, Cs=10, y_test = y[test] if sample_weight is not None: - sample_weight = check_array(sample_weight, ensure_2d=False) - check_consistent_length(y, sample_weight) - + sample_weight = _check_sample_weight(sample_weight, X) sample_weight = sample_weight[train] coefs, Cs, n_iter = _logistic_regression_path( diff --git a/sklearn/linear_model/ransac.py b/sklearn/linear_model/ransac.py index 7f4fb650b59e8..b901e848f49bf 100644 --- a/sklearn/linear_model/ransac.py +++ b/sklearn/linear_model/ransac.py @@ -11,7 +11,7 @@ from ..base import MultiOutputMixin from ..utils import check_random_state, check_array, check_consistent_length from ..utils.random import sample_without_replacement -from ..utils.validation import check_is_fitted +from ..utils.validation import check_is_fitted, _check_sample_weight from .base import LinearRegression from ..utils.validation import has_fit_parameter from ..exceptions import ConvergenceWarning @@ -324,8 +324,7 @@ def fit(self, X, y, sample_weight=None): raise ValueError("%s does not support sample_weight. Samples" " weights are only used for the calibration" " itself." % estimator_name) - if sample_weight is not None: - sample_weight = np.asarray(sample_weight) + sample_weight = _check_sample_weight(sample_weight, X) n_inliers_best = 1 score_best = -np.inf diff --git a/sklearn/linear_model/ridge.py b/sklearn/linear_model/ridge.py index 45862d5f3cffb..cc3b6a518add5 100644 --- a/sklearn/linear_model/ridge.py +++ b/sklearn/linear_model/ridge.py @@ -27,6 +27,7 @@ from ..utils import check_consistent_length from ..utils import compute_sample_weight from ..utils import column_or_1d +from ..utils.validation import _check_sample_weight from ..preprocessing import LabelBinarizer from ..model_selection import GridSearchCV from ..metrics.scorer import check_scoring @@ -428,8 +429,7 @@ def _ridge_regression(X, y, alpha, sample_weight=None, solver='auto', " %d != %d" % (n_samples, n_samples_)) if has_sw: - if np.atleast_1d(sample_weight).ndim > 1: - raise ValueError("Sample weights must be 1D array or scalar") + sample_weight = _check_sample_weight(sample_weight, X, dtype=X.dtype) if solver not in ['sag', 'saga']: # SAG supports sample_weight directly. For other solvers, @@ -1406,9 +1406,8 @@ def fit(self, X, y, sample_weight=None): "alphas must be positive. Got {} containing some " "negative or null value instead.".format(self.alphas)) - if sample_weight is not None and not isinstance(sample_weight, float): - sample_weight = check_array(sample_weight, ensure_2d=False, - dtype=X.dtype) + sample_weight = _check_sample_weight(sample_weight, X, dtype=X.dtype) + n_samples, n_features = X.shape X, y, X_offset, y_offset, X_scale = LinearModel._preprocess_data( diff --git a/sklearn/linear_model/sag.py b/sklearn/linear_model/sag.py index 233a6ed1c50af..fa02c7a4a0ef8 100644 --- a/sklearn/linear_model/sag.py +++ b/sklearn/linear_model/sag.py @@ -12,6 +12,7 @@ from .sag_fast import sag32, sag64 from ..exceptions import ConvergenceWarning from ..utils import check_array +from ..utils.validation import _check_sample_weight from ..utils.extmath import row_norms @@ -251,8 +252,7 @@ def sag_solver(X, y, sample_weight=None, loss='log', alpha=1., beta=0., n_classes = int(y.max()) + 1 if loss == 'multinomial' else 1 # initialization - if sample_weight is None: - sample_weight = np.ones(n_samples, dtype=X.dtype, order='C') + sample_weight = _check_sample_weight(sample_weight, X, dtype=X.dtype) if 'coef' in warm_start_mem.keys(): coef_init = warm_start_mem['coef'] diff --git a/sklearn/linear_model/stochastic_gradient.py b/sklearn/linear_model/stochastic_gradient.py index 625bdb5bdc3f9..25b63a3a0cdce 100644 --- a/sklearn/linear_model/stochastic_gradient.py +++ b/sklearn/linear_model/stochastic_gradient.py @@ -18,7 +18,7 @@ from ..utils import check_array, check_random_state, check_X_y from ..utils.extmath import safe_sparse_dot from ..utils.multiclass import _check_partial_fit_first_call -from ..utils.validation import check_is_fitted +from ..utils.validation import check_is_fitted, _check_sample_weight from ..exceptions import ConvergenceWarning from ..model_selection import StratifiedShuffleSplit, ShuffleSplit @@ -169,19 +169,6 @@ def _get_penalty_type(self, penalty): except KeyError: raise ValueError("Penalty %s is not supported. " % penalty) - def _validate_sample_weight(self, sample_weight, n_samples): - """Set the sample weight array.""" - if sample_weight is None: - # uniform sample weights - sample_weight = np.ones(n_samples, dtype=np.float64, order='C') - else: - # user-provided array - sample_weight = np.asarray(sample_weight, dtype=np.float64, - order="C") - if sample_weight.shape[0] != n_samples: - raise ValueError("Shapes of X and sample_weight do not match.") - return sample_weight - def _allocate_parameter_mem(self, n_classes, n_features, coef_init=None, intercept_init=None): """Allocate mem for parameters; initialize if provided.""" @@ -488,7 +475,7 @@ def _partial_fit(self, X, y, alpha, C, # Allocate datastructures from input arguments self._expanded_class_weight = compute_class_weight(self.class_weight, self.classes_, y) - sample_weight = self._validate_sample_weight(sample_weight, n_samples) + sample_weight = _check_sample_weight(sample_weight, X) if getattr(self, "coef_", None) is None or coef_init is not None: self._allocate_parameter_mem(n_classes, n_features, @@ -1095,9 +1082,9 @@ def _partial_fit(self, X, y, alpha, C, loss, learning_rate, n_samples, n_features = X.shape - # Allocate datastructures from input arguments - sample_weight = self._validate_sample_weight(sample_weight, n_samples) + sample_weight = _check_sample_weight(sample_weight, X) + # Allocate datastructures from input arguments if getattr(self, "coef_", None) is None: self._allocate_parameter_mem(1, n_features, coef_init, intercept_init) diff --git a/sklearn/svm/base.py b/sklearn/svm/base.py index 4a50ee479f030..e27abeed7ecee 100644 --- a/sklearn/svm/base.py +++ b/sklearn/svm/base.py @@ -8,11 +8,12 @@ from ..base import BaseEstimator, ClassifierMixin from ..preprocessing import LabelEncoder from ..utils.multiclass import _ovr_decision_function -from ..utils import check_array, check_consistent_length, check_random_state +from ..utils import check_array, check_random_state from ..utils import column_or_1d, check_X_y from ..utils import compute_class_weight from ..utils.extmath import safe_sparse_dot from ..utils.validation import check_is_fitted, _check_large_sparse +from ..utils.validation import _check_sample_weight from ..utils.multiclass import check_classification_targets from ..exceptions import ConvergenceWarning from ..exceptions import NotFittedError @@ -906,11 +907,9 @@ def _fit_liblinear(X, y, C, fit_intercept, intercept_scaling, class_weight, # LibLinear wants targets as doubles, even for classification y_ind = np.asarray(y_ind, dtype=np.float64).ravel() y_ind = np.require(y_ind, requirements="W") - if sample_weight is None: - sample_weight = np.ones(X.shape[0]) - else: - sample_weight = np.array(sample_weight, dtype=np.float64, order='C') - check_consistent_length(sample_weight, X) + + sample_weight = _check_sample_weight(sample_weight, X, + dtype=np.float64) solver_type = _get_liblinear_solver_type(multi_class, penalty, loss, dual) raw_coef_, n_iter_ = liblinear.train_wrap( diff --git a/sklearn/utils/validation.py b/sklearn/utils/validation.py index bb6cf1c8ffe00..abf51eef8f487 100644 --- a/sklearn/utils/validation.py +++ b/sklearn/utils/validation.py @@ -980,3 +980,53 @@ def check_scalar(x, name, target_type, min_val=None, max_val=None): if max_val is not None and x > max_val: raise ValueError('`{}`= {}, must be <= {}.'.format(name, x, max_val)) + + +def _check_sample_weight(sample_weight, X, dtype=None): + """Validate sample weights. + + Parameters + ---------- + sample_weight : {ndarray, Number or None}, shape (n_samples,) + Input sample weights. + + X : nd-array, list or sparse matrix + Input data. + + dtype: dtype + dtype of the validated `sample_weight`. + If None, and the input `sample_weight` is an array, the dtype of the + input is preserved; otherwise an array with the default numpy dtype + is be allocated. If `dtype` is not one of `float32`, `float64`, + `None`, the output will be of dtype `float64`. + + Returns + ------- + sample_weight : ndarray, shape (n_samples,) + Validated sample weight. It is guaranteed to be "C" contiguous. + """ + n_samples = _num_samples(X) + + if dtype is not None and dtype not in [np.float32, np.float64]: + dtype = np.float64 + + if sample_weight is None or isinstance(sample_weight, numbers.Number): + if sample_weight is None: + sample_weight = np.ones(n_samples, dtype=dtype) + else: + sample_weight = np.full(n_samples, sample_weight, + dtype=dtype) + else: + if dtype is None: + dtype = [np.float64, np.float32] + sample_weight = check_array( + sample_weight, accept_sparse=False, + ensure_2d=False, dtype=dtype, order="C" + ) + if sample_weight.ndim != 1: + raise ValueError("Sample weights must be 1D array or scalar") + + if sample_weight.shape != (n_samples,): + raise ValueError("sample_weight.shape == {}, expected {}!" + .format(sample_weight.shape, (n_samples,))) + return sample_weight	diff --git a/sklearn/cluster/tests/test_k_means.py b/sklearn/cluster/tests/test_k_means.py index 4266dc6a17899..362b0a9145fca 100644 --- a/sklearn/cluster/tests/test_k_means.py +++ b/sklearn/cluster/tests/test_k_means.py @@ -909,14 +909,15 @@ def test_sample_weight_length(): # check that an error is raised when passing sample weights # with an incompatible shape km = KMeans(n_clusters=n_clusters, random_state=42) - assert_raises_regex(ValueError, r'len\(sample_weight\)', km.fit, X, - sample_weight=np.ones(2)) + msg = r'sample_weight.shape == \(2,\), expected \(100,\)' + with pytest.raises(ValueError, match=msg): + km.fit(X, sample_weight=np.ones(2)) -def test_check_sample_weight(): - from sklearn.cluster.k_means_ import _check_sample_weight +def test_check_normalize_sample_weight(): + from sklearn.cluster.k_means_ import _check_normalize_sample_weight sample_weight = None - checked_sample_weight = _check_sample_weight(X, sample_weight) + checked_sample_weight = _check_normalize_sample_weight(sample_weight, X) assert _num_samples(X) == _num_samples(checked_sample_weight) assert_almost_equal(checked_sample_weight.sum(), _num_samples(X)) assert X.dtype == checked_sample_weight.dtype diff --git a/sklearn/utils/tests/test_validation.py b/sklearn/utils/tests/test_validation.py index 0aa8eae22b1e2..2789a59344008 100644 --- a/sklearn/utils/tests/test_validation.py +++ b/sklearn/utils/tests/test_validation.py @@ -20,6 +20,7 @@ from sklearn.utils.testing import SkipTest from sklearn.utils.testing import assert_array_equal from sklearn.utils.testing import assert_allclose_dense_sparse +from sklearn.utils.testing import assert_allclose from sklearn.utils import as_float_array, check_array, check_symmetric from sklearn.utils import check_X_y from sklearn.utils import deprecated @@ -39,7 +40,8 @@ check_memory, check_non_negative, _num_samples, - check_scalar) + check_scalar, + _check_sample_weight) import sklearn from sklearn.exceptions import NotFittedError @@ -853,3 +855,40 @@ def test_check_scalar_invalid(x, target_name, target_type, min_val, max_val, min_val=min_val, max_val=max_val) assert str(raised_error.value) == str(err_msg) assert type(raised_error.value) == type(err_msg) + + +def test_check_sample_weight(): + # check array order + sample_weight = np.ones(10)[::2] + assert not sample_weight.flags["C_CONTIGUOUS"] + sample_weight = _check_sample_weight(sample_weight, X=np.ones((5, 1))) + assert sample_weight.flags["C_CONTIGUOUS"] + + # check None input + sample_weight = _check_sample_weight(None, X=np.ones((5, 2))) + assert_allclose(sample_weight, np.ones(5)) + + # check numbers input + sample_weight = _check_sample_weight(2.0, X=np.ones((5, 2))) + assert_allclose(sample_weight, 2 * np.ones(5)) + + # check wrong number of dimensions + with pytest.raises(ValueError, + match="Sample weights must be 1D array or scalar"): + _check_sample_weight(np.ones((2, 4)), X=np.ones((2, 2))) + + # check incorrect n_samples + msg = r"sample_weight.shape == \(4,\), expected \(2,\)!" + with pytest.raises(ValueError, match=msg): + _check_sample_weight(np.ones(4), X=np.ones((2, 2))) + + # float32 dtype is preserved + X = np.ones((5, 2)) + sample_weight = np.ones(5, dtype=np.float32) + sample_weight = _check_sample_weight(sample_weight, X) + assert sample_weight.dtype == np.float32 + + # int dtype will be converted to float64 instead + X = np.ones((5, 2), dtype=np.int) + sample_weight = _check_sample_weight(None, X, dtype=X.dtype) + assert sample_weight.dtype == np.float64		[ { "components": [ { "doc": "Set sample_weight if None, and check for correct dtype", "lines": [ 167, 179 ], "name": "_check_normalize_sample_weight", "signature": "def _check_normalize_sample_weight(sample_weight, X):", "type": "function"...	[ "sklearn/cluster/tests/test_k_means.py::test_kmeans_results[float32-dense-full]", "sklearn/cluster/tests/test_k_means.py::test_kmeans_results[float32-dense-elkan]", "sklearn/cluster/tests/test_k_means.py::test_kmeans_results[float32-sparse-full]", "sklearn/cluster/tests/test_k_means.py::test_kmeans_results[fl...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> MAINT Common sample_weight validation This implements a helper function for sample weight validation, and uses it consistently across the code base when applicable. Currently it's only applied to estimators (particularly in linear models and SVM) that already had some form of sample weight validation. It the future it might be worthwhile to add it to estimators that don't currently validate sample weights. It is a pre-requisite for optionally enforcing positive sample weights (https://github.com/scikit-learn/scikit-learn/issues/12464) Also somewhat related to https://github.com/scikit-learn/scikit-learn/pull/14286 and https://github.com/scikit-learn/scikit-learn/pull/14294 The main motivation is to avoid implementing this yet another time for GLMs in https://github.com/scikit-learn/scikit-learn/pull/14300 Any thought on this @glemaitre , since you were looking into related issues lately? ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/cluster/k_means_.py] (definition of _check_normalize_sample_weight:) def _check_normalize_sample_weight(sample_weight, X): """Set sample_weight if None, and check for correct dtype""" [end of new definitions in sklearn/cluster/k_means_.py] [start of new definitions in sklearn/utils/validation.py] (definition of _check_sample_weight:) def _check_sample_weight(sample_weight, X, dtype=None): """Validate sample weights. Parameters ---------- sample_weight : {ndarray, Number or None}, shape (n_samples,) Input sample weights. X : nd-array, list or sparse matrix Input data. dtype: dtype dtype of the validated `sample_weight`. If None, and the input `sample_weight` is an array, the dtype of the input is preserved; otherwise an array with the default numpy dtype is be allocated. If `dtype` is not one of `float32`, `float64`, `None`, the output will be of dtype `float64`. Returns ------- sample_weight : ndarray, shape (n_samples,) Validated sample weight. It is guaranteed to be "C" contiguous.""" [end of new definitions in sklearn/utils/validation.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c96e0958da46ebef482a4084cdda3285d5f5ad23
sympy__sympy-17174	17,174	sympy/sympy	1.5	8ca4a683d58ac1f61cfd2e4dacf7f58b9c0fefab	2019-07-11T16:16:07Z	diff --git a/sympy/stats/__init__.py b/sympy/stats/__init__.py index 6ae2ce1a961f..0527237d119a 100644 --- a/sympy/stats/__init__.py +++ b/sympy/stats/__init__.py @@ -94,6 +94,17 @@ ) __all__.extend(stochastic_process_types.__all__) +from . import random_matrix_models +from .random_matrix_models import ( + GaussianEnsemble, + GaussianUnitaryEnsemble, + GaussianOrthogonalEnsemble, + GaussianSymplecticEnsemble, + joint_eigen_distribution, + level_spacing_distribution +) +__all__.extend(random_matrix_models.__all__) + from . import symbolic_probability from .symbolic_probability import Probability, Expectation, Variance, Covariance __all__.extend(symbolic_probability.__all__) diff --git a/sympy/stats/random_matrix.py b/sympy/stats/random_matrix.py new file mode 100644 index 000000000000..126f6a322315 --- /dev/null +++ b/sympy/stats/random_matrix.py @@ -0,0 +1,24 @@ +from __future__ import print_function, division + +from sympy import Basic, MatrixSymbol +from sympy.stats.rv import PSpace, _symbol_converter, RandomMatrixSymbol + +class RandomMatrixPSpace(PSpace): + """ + Represents probability space for + random matrices. It contains the mechanics + for handling the API calls for random matrices. + """ + def __new__(cls, sym, model=None): + sym = _symbol_converter(sym) + return Basic.__new__(cls, sym, model) + + model = property(lambda self: self.args[1]) + + def compute_density(self, expr, args): + rms = expr.atoms(RandomMatrixSymbol) + if len(rms) > 2 or (not isinstance(expr, RandomMatrixSymbol)): + raise NotImplementedError("Currently, no algorithm has been " + "implemented to handle general expressions containing " + "multiple random matrices.") + return self.model.density(expr) diff --git a/sympy/stats/random_matrix_models.py b/sympy/stats/random_matrix_models.py new file mode 100644 index 000000000000..277e20eecf47 --- /dev/null +++ b/sympy/stats/random_matrix_models.py @@ -0,0 +1,245 @@ +from __future__ import print_function, division + +from sympy import (Basic, exp, pi, Lambda, Trace, S, MatrixSymbol, Integral, + gamma, Product, Dummy, Sum, Abs, IndexedBase) +from sympy.core.sympify import _sympify +from sympy.multipledispatch import dispatch +from sympy.stats.rv import _symbol_converter, Density, RandomMatrixSymbol +from sympy.stats.random_matrix import RandomMatrixPSpace +from sympy.tensor.array import ArrayComprehension + +__all__ = [ + 'GaussianEnsemble', + 'GaussianUnitaryEnsemble', + 'GaussianOrthogonalEnsemble', + 'GaussianSymplecticEnsemble', + 'joint_eigen_distribution', + 'level_spacing_distribution' +] + +class RandomMatrixEnsemble(Basic): + """ + Abstract class for random matrix ensembles. + It acts as an umbrella for all the ensembles + defined in sympy.stats.random_matrix_models. + """ + pass + +class GaussianEnsemble(RandomMatrixEnsemble): + """ + Abstract class for Gaussian ensembles. + Contains the properties common to all the + gaussian ensembles. + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Random_matrix#Gaussian_ensembles + .. [2] https://arxiv.org/pdf/1712.07903.pdf + """ + def __new__(cls, sym, dim=None): + sym, dim = _symbol_converter(sym), _sympify(dim) + if dim.is_integer == False: + raise ValueError("Dimension of the random matrices must be " + "integers, received %s instead."%(dim)) + self = Basic.__new__(cls, sym, dim) + rmp = RandomMatrixPSpace(sym, model=self) + return RandomMatrixSymbol(sym, dim, dim, pspace=rmp) + + symbol = property(lambda self: self.args[0]) + dimension = property(lambda self: self.args[1]) + + def density(self, expr): + return Density(expr) + + def _compute_normalization_constant(self, beta, n): + """ + Helper function for computing normalization + constant for joint probability density of eigen + values of Gaussian ensembles. + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Selberg_integral#Mehta's_integral + """ + n = S(n) + prod_term = lambda j: gamma(1 + betaS(j)/2)/gamma(S(1) + beta/S(2)) + j = Dummy('j', integer=True, positive=True) + term1 = Product(prod_term(j), (j, 1, n)).doit() + term2 = (2/(betan))(betan(n - 1)/4 + n/2) + term3 = (2pi)*(n/2) + return term1 term2 * term3 + + def _compute_joint_eigen_dsitribution(self, beta): + """ + Helper function for computing the joint + probability distribution of eigen values + of the random matrix. + """ + n = self.dimension + Zbn = self._compute_normalization_constant(beta, n) + l = IndexedBase('l') + i = Dummy('i', integer=True, positive=True) + j = Dummy('j', integer=True, positive=True) + k = Dummy('k', integer=True, positive=True) + term1 = exp((-S(n)/2) * Sum(l[k]2, (k, 1, n)).doit()) + sub_term = Lambda(i, Product(Abs(l[j] - l[i])beta, (j, i + 1, n))) + term2 = Product(sub_term(i).doit(), (i, 1, n - 1)).doit() + syms = ArrayComprehension(l[k], (k, 1, n)).doit() + return Lambda(syms, (term1 * term2)/Zbn) + +class GaussianUnitaryEnsemble(GaussianEnsemble): + """ + Represents Gaussian Unitary Ensembles. + + Examples + ======== + + >>> from sympy.stats import GaussianUnitaryEnsemble as GUE, density + >>> G = GUE('U', 2) + >>> density(G) + Lambda(H, exp(-Trace(H*2))/(2pi2)) + """ + @property + def normalization_constant(self): + n = self.dimension + return 2(S(n)/2) * pi(S(n2)/2) + + def density(self, expr): + n, ZGUE = self.dimension, self.normalization_constant + h_pspace = RandomMatrixPSpace('P', model=self) + H = RandomMatrixSymbol('H', n, n, pspace=h_pspace) + return Lambda(H, exp(-S(n)/2 * Trace(H2))/ZGUE) + + def joint_eigen_distribution(self): + return self._compute_joint_eigen_dsitribution(2) + + def level_spacing_distribution(self): + s = Dummy('s') + f = (32/pi2)(s2)exp((-4/pi)s2) + return Lambda(s, f) + +class GaussianOrthogonalEnsemble(GaussianEnsemble): + """ + Represents Gaussian Orthogonal Ensembles. + + Examples + ======== + + >>> from sympy.stats import GaussianOrthogonalEnsemble as GOE, density + >>> G = GOE('U', 2) + >>> density(G) + Lambda(H, exp(-Trace(H2)/2)/Integral(exp(-Trace(_H2)/2), _H)) + """ + @property + def normalization_constant(self): + n = self.dimension + _H = MatrixSymbol('_H', n, n) + return Integral(exp(-S(n)/4 Trace(_H*2))) + + def density(self, expr): + n, ZGOE = self.dimension, self.normalization_constant + h_pspace = RandomMatrixPSpace('P', model=self) + H = RandomMatrixSymbol('H', n, n, pspace=h_pspace) + return Lambda(H, exp(-S(n)/4 Trace(H*2))/ZGOE) + + def joint_eigen_distribution(self): + return self._compute_joint_eigen_dsitribution(1) + + def level_spacing_distribution(self): + s = Dummy('s') + f = (pi/2)sexp((-pi/4)s*2) + return Lambda(s, f) + +class GaussianSymplecticEnsemble(GaussianEnsemble): + """ + Represents Gaussian Symplectic Ensembles. + + Examples + ======== + + >>> from sympy.stats import GaussianSymplecticEnsemble as GSE, density + >>> G = GSE('U', 2) + >>> density(G) + Lambda(H, exp(-2Trace(H*2))/Integral(exp(-2Trace(_H*2)), _H)) + """ + @property + def normalization_constant(self): + n = self.dimension + _H = MatrixSymbol('_H', n, n) + return Integral(exp(-S(n) Trace(_H*2))) + + def density(self, expr): + n, ZGSE = self.dimension, self.normalization_constant + h_pspace = RandomMatrixPSpace('P', model=self) + H = RandomMatrixSymbol('H', n, n, pspace=h_pspace) + return Lambda(H, exp(-S(n) Trace(H2))/ZGSE) + + def joint_eigen_distribution(self): + return self._compute_joint_eigen_dsitribution(4) + + def level_spacing_distribution(self): + s = Dummy('s') + f = ((S(2)18)/((S(3)*6)(pi*3)))(s*4)exp((-64/(9pi))s2) + return Lambda(s, f) + +@dispatch(RandomMatrixSymbol) +def joint_eigen_distribution(mat): + """ + For obtaining joint probability distribution + of eigen values of random matrix. + + Parameters + ========== + + mat: RandomMatrixSymbol + The matrix symbol whose eigen values are to be considered. + + Returns + ======= + + Lambda + + Examples + ======== + + >>> from sympy.stats import GaussianUnitaryEnsemble as GUE + >>> from sympy.stats import joint_eigen_distribution + >>> U = GUE('U', 2) + >>> joint_eigen_dsitribution(U) + Lambda((l[1], l[2]), exp(-l[1]2 - l[2]*2)Product(Abs(l[_i] - l[_j])*2, (_j, _i + 1, 2), (_i, 1, 1))/pi) + """ + return mat.pspace.model.joint_eigen_distribution() + +def level_spacing_distribution(mat): + """ + For obtaining distribution of level spacings. + + Parameters + ========== + + mat: RandomMatrixSymbol + The random matrix symbol whose eigen values are + to be considered for finding the level spacings. + + Returns + ======= + + Lambda + + Examples + ======== + + >>> from sympy.stats import GaussianUnitaryEnsemble as GUE + >>> from sympy.stats import level_spacing_distribution + >>> U = GUE('U', 2) + >>> level_spacing_distribution(U) + Lambda(_s, 32_s*2exp(-4_s2/pi)/pi2) + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Random_matrix#Distribution_of_level_spacings + """ + return mat.pspace.model.level_spacing_distribution() diff --git a/sympy/stats/rv.py b/sympy/stats/rv.py index 43250c1a4044..7c5e6f464307 100644 --- a/sympy/stats/rv.py +++ b/sympy/stats/rv.py @@ -17,9 +17,10 @@ from sympy import (Basic, S, Expr, Symbol, Tuple, And, Add, Eq, lambdify, Equality, Lambda, sympify, Dummy, Ne, KroneckerDelta, - DiracDelta, Mul, Indexed, Function) + DiracDelta, Mul, Indexed, MatrixSymbol, Function) from sympy.core.compatibility import string_types from sympy.core.relational import Relational +from sympy.core.sympify import _sympify from sympy.logic.boolalg import Boolean from sympy.sets.sets import FiniteSet, ProductSet, Intersection from sympy.solvers.solveset import solveset @@ -289,6 +290,16 @@ def key(self): elif isinstance(self.symbol, Function): return self.symbol.args[0] +class RandomMatrixSymbol(MatrixSymbol): + def __new__(cls, symbol, n, m, pspace=None): + from sympy.stats.random_matrix import RandomMatrixPSpace + n, m = _sympify(n), _sympify(m) + symbol = _symbol_converter(symbol) + return Basic.__new__(cls, symbol, n, m, pspace) + + symbol = property(lambda self: self.args[0]) + pspace = property(lambda self: self.args[3]) + class ProductPSpace(PSpace): """ Abstract class for representing probability spaces with multiple random @@ -545,6 +556,10 @@ def pspace(expr): expr = sympify(expr) if isinstance(expr, RandomSymbol) and expr.pspace is not None: return expr.pspace + if expr.has(RandomMatrixSymbol): + rm = list(expr.atoms(RandomMatrixSymbol))[0] + return rm.pspace + rvs = random_symbols(expr) if not rvs: raise ValueError("Expression containing Random Variable expected, not %s" % (expr)) @@ -803,7 +818,10 @@ def condition(self): def doit(self, evaluate=True, *kwargs): from sympy.stats.joint_rv import JointPSpace from sympy.stats.frv import SingleFiniteDistribution + from sympy.stats.random_matrix_models import RandomMatrixPSpace expr, condition = self.expr, self.condition + if _sympify(expr).has(RandomMatrixSymbol): + return pspace(expr).compute_density(expr) if isinstance(expr, SingleFiniteDistribution): return expr.dict if condition is not None:	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index a4ac9ff6f349..d28040d6b2e7 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1563,6 +1563,12 @@ def test_sympy__stats__rv__RandomIndexedSymbol(): X = DiscreteMarkovChain("X") assert _test_args(RandomIndexedSymbol(X[0].symbol, pspace(X[0]))) +def test_sympy__stats__rv__RandomMatrixSymbol(): + from sympy.stats.rv import RandomMatrixSymbol + from sympy.stats.random_matrix import RandomMatrixPSpace + pspace = RandomMatrixPSpace('P') + assert _test_args(RandomMatrixSymbol('M', 3, 3, pspace)) + def test_sympy__stats__stochastic_process__StochasticPSpace(): from sympy.stats.stochastic_process import StochasticPSpace from sympy.stats.stochastic_process_types import StochasticProcess @@ -1613,6 +1619,31 @@ def test_sympy__stats__stochastic_process_types__ContinuousMarkovChain(): from sympy import MatrixSymbol assert _test_args(ContinuousMarkovChain("Y", [0, 1, 2], MatrixSymbol('T', 3, 3))) +def test_sympy__stats__random_matrix__RandomMatrixPSpace(): + from sympy.stats.random_matrix import RandomMatrixPSpace + from sympy.stats.random_matrix_models import RandomMatrixEnsemble + assert _test_args(RandomMatrixPSpace('P', RandomMatrixEnsemble())) + +def test_sympy__stats__random_matrix_models__RandomMatrixEnsemble(): + from sympy.stats.random_matrix_models import RandomMatrixEnsemble + assert _test_args(RandomMatrixEnsemble()) + +def test_sympy__stats__random_matrix_models__GaussianEnsemble(): + from sympy.stats.random_matrix_models import GaussianEnsemble + assert _test_args(GaussianEnsemble('G', 3)) + +def test_sympy__stats__random_matrix_models__GaussianUnitaryEnsemble(): + from sympy.stats import GaussianUnitaryEnsemble + assert _test_args(GaussianUnitaryEnsemble('U', 3)) + +def test_sympy__stats__random_matrix_models__GaussianOrthogonalEnsemble(): + from sympy.stats import GaussianOrthogonalEnsemble + assert _test_args(GaussianOrthogonalEnsemble('U', 3)) + +def test_sympy__stats__random_matrix_models__GaussianSymplecticEnsemble(): + from sympy.stats import GaussianSymplecticEnsemble + assert _test_args(GaussianSymplecticEnsemble('U', 3)) + def test_sympy__core__symbol__Dummy(): from sympy.core.symbol import Dummy assert _test_args(Dummy('t')) diff --git a/sympy/stats/tests/test_random_matrix.py b/sympy/stats/tests/test_random_matrix.py new file mode 100644 index 000000000000..2984692fa735 --- /dev/null +++ b/sympy/stats/tests/test_random_matrix.py @@ -0,0 +1,60 @@ +from sympy import (sqrt, exp, Trace, pi, S, Integral, MatrixSymbol, Lambda, + Dummy, Product, Sum, Abs, IndexedBase) +from sympy.stats import (GaussianUnitaryEnsemble as GUE, density, + GaussianOrthogonalEnsemble as GOE, + GaussianSymplecticEnsemble as GSE, + joint_eigen_distribution, + level_spacing_distribution) +from sympy.stats.rv import RandomMatrixSymbol, Density +from sympy.stats.random_matrix_models import GaussianEnsemble +from sympy.utilities.pytest import raises + +def test_GaussianEnsemble(): + G = GaussianEnsemble('G', 3) + assert density(G) == Density(G) + raises(ValueError, lambda: GaussianEnsemble('G', 3.5)) + +def test_GaussianUnitaryEnsemble(): + H = RandomMatrixSymbol('H', 3, 3) + G = GUE('U', 3) + assert density(G)(H) == sqrt(2)exp(-3Trace(H*2)/2)/(4pi*(S(9)/2)) + i, j = (Dummy('i', integer=True, positive=True), + Dummy('j', integer=True, positive=True)) + l = IndexedBase('l') + assert joint_eigen_distribution(G).dummy_eq( + Lambda((l[1], l[2], l[3]), + 27sqrt(6)exp(-3(l[1]*2)/2 - 3(l[2]*2)/2 - 3(l[3]*2)/2) + Product(Abs(l[i] - l[j])*2, (j, i + 1, 3), (i, 1, 2))/(16pi*(S(3)/2)))) + s = Dummy('s') + assert level_spacing_distribution(G).dummy_eq(Lambda(s, 32s*2exp(-4s2/pi)/pi2)) + + +def test_GaussianOrthogonalEnsemble(): + H = RandomMatrixSymbol('H', 3, 3) + _H = MatrixSymbol('_H', 3, 3) + G = GOE('O', 3) + assert density(G)(H) == exp(-3Trace(H*2)/4)/Integral(exp(-3Trace(_H*2)/4), _H) + i, j = (Dummy('i', integer=True, positive=True), + Dummy('j', integer=True, positive=True)) + l = IndexedBase('l') + assert joint_eigen_distribution(G).dummy_eq( + Lambda((l[1], l[2], l[3]), + 9sqrt(2)exp(-3l[1]*2/2 - 3l[2]*2/2 - 3l[3]*2/2) + Product(Abs(l[i] - l[j]), (j, i + 1, 3), (i, 1, 2))/(32pi))) + s = Dummy('s') + assert level_spacing_distribution(G).dummy_eq(Lambda(s, spiexp(-s2pi/4)/2)) + +def test_GaussianSymplecticEnsemble(): + H = RandomMatrixSymbol('H', 3, 3) + _H = MatrixSymbol('_H', 3, 3) + G = GSE('O', 3) + assert density(G)(H) == exp(-3Trace(H2))/Integral(exp(-3Trace(_H*2)), _H) + i, j = (Dummy('i', integer=True, positive=True), + Dummy('j', integer=True, positive=True)) + l = IndexedBase('l') + assert joint_eigen_distribution(G).dummy_eq( + Lambda((l[1], l[2], l[3]), + 162sqrt(3)exp(-3l[1]*2/2 - 3l[2]*2/2 - 3l[3]*2/2) + Product(Abs(l[i] - l[j])*4, (j, i + 1, 3), (i, 1, 2))/(5pi*(S(3)/2)))) + s = Dummy('s') + assert level_spacing_distribution(G).dummy_eq(Lambda(s, S(262144)s*4exp(-64s2/(9pi))/(729pi*3)))		[ { "components": [ { "doc": "Represents probability space for\nrandom matrices. It contains the mechanics\nfor handling the API calls for random matrices.", "lines": [ 6, 24 ], "name": "RandomMatrixPSpace", "signature": "class RandomMatrixPSpace(P...	[ "test_sympy__stats__rv__RandomMatrixSymbol", "test_sympy__stats__random_matrix__RandomMatrixPSpace", "test_sympy__stats__random_matrix_models__RandomMatrixEnsemble", "test_sympy__stats__random_matrix_models__GaussianEnsemble", "test_sympy__stats__random_matrix_models__GaussianUnitaryEnsemble", "test_sympy...	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added random matrices(Gaussian Ensembles only) <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> [1] https://github.com/sympy/sympy/issues/17039 #### Brief description of what is fixed or changed I have added framework random matrices. #### Other comments This is a work in progress. The first commit depicts how the framework for random matrices will look like. More features will added in the upcoming updates. #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * stats * Random matrices have been added to `sympy.stats` <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/random_matrix.py] (definition of RandomMatrixPSpace:) class RandomMatrixPSpace(PSpace): """Represents probability space for random matrices. It contains the mechanics for handling the API calls for random matrices.""" (definition of RandomMatrixPSpace.__new__:) def __new__(cls, sym, model=None): (definition of RandomMatrixPSpace.compute_density:) def compute_density(self, expr, args): [end of new definitions in sympy/stats/random_matrix.py] [start of new definitions in sympy/stats/random_matrix_models.py] (definition of RandomMatrixEnsemble:) class RandomMatrixEnsemble(Basic): """Abstract class for random matrix ensembles. It acts as an umbrella for all the ensembles defined in sympy.stats.random_matrix_models.""" (definition of GaussianEnsemble:) class GaussianEnsemble(RandomMatrixEnsemble): """Abstract class for Gaussian ensembles. Contains the properties common to all the gaussian ensembles. References ========== .. [1] https://en.wikipedia.org/wiki/Random_matrix#Gaussian_ensembles .. [2] https://arxiv.org/pdf/1712.07903.pdf""" (definition of GaussianEnsemble.__new__:) def __new__(cls, sym, dim=None): (definition of GaussianEnsemble.density:) def density(self, expr): (definition of GaussianEnsemble._compute_normalization_constant:) def _compute_normalization_constant(self, beta, n): """Helper function for computing normalization constant for joint probability density of eigen values of Gaussian ensembles. References ========== .. [1] https://en.wikipedia.org/wiki/Selberg_integral#Mehta's_integral""" (definition of GaussianEnsemble._compute_joint_eigen_dsitribution:) def _compute_joint_eigen_dsitribution(self, beta): """Helper function for computing the joint probability distribution of eigen values of the random matrix.""" (definition of GaussianUnitaryEnsemble:) class GaussianUnitaryEnsemble(GaussianEnsemble): """Represents Gaussian Unitary Ensembles. Examples ======== >>> from sympy.stats import GaussianUnitaryEnsemble as GUE, density >>> G = GUE('U', 2) >>> density(G) Lambda(H, exp(-Trace(H2))/(2pi2))""" (definition of GaussianUnitaryEnsemble.normalization_constant:) def normalization_constant(self): (definition of GaussianUnitaryEnsemble.density:) def density(self, expr): (definition of GaussianUnitaryEnsemble.joint_eigen_distribution:) def joint_eigen_distribution(self): (definition of GaussianUnitaryEnsemble.level_spacing_distribution:) def level_spacing_distribution(self): (definition of GaussianOrthogonalEnsemble:) class GaussianOrthogonalEnsemble(GaussianEnsemble): """Represents Gaussian Orthogonal Ensembles. Examples ======== >>> from sympy.stats import GaussianOrthogonalEnsemble as GOE, density >>> G = GOE('U', 2) >>> density(G) Lambda(H, exp(-Trace(H2)/2)/Integral(exp(-Trace(_H*2)/2), _H))""" (definition of GaussianOrthogonalEnsemble.normalization_constant:) def normalization_constant(self): (definition of GaussianOrthogonalEnsemble.density:) def density(self, expr): (definition of GaussianOrthogonalEnsemble.joint_eigen_distribution:) def joint_eigen_distribution(self): (definition of GaussianOrthogonalEnsemble.level_spacing_distribution:) def level_spacing_distribution(self): (definition of GaussianSymplecticEnsemble:) class GaussianSymplecticEnsemble(GaussianEnsemble): """Represents Gaussian Symplectic Ensembles. Examples ======== >>> from sympy.stats import GaussianSymplecticEnsemble as GSE, density >>> G = GSE('U', 2) >>> density(G) Lambda(H, exp(-2Trace(H*2))/Integral(exp(-2Trace(_H2)), _H))""" (definition of GaussianSymplecticEnsemble.normalization_constant:) def normalization_constant(self): (definition of GaussianSymplecticEnsemble.density:) def density(self, expr): (definition of GaussianSymplecticEnsemble.joint_eigen_distribution:) def joint_eigen_distribution(self): (definition of GaussianSymplecticEnsemble.level_spacing_distribution:) def level_spacing_distribution(self): (definition of joint_eigen_distribution:) def joint_eigen_distribution(mat): """For obtaining joint probability distribution of eigen values of random matrix. Parameters ========== mat: RandomMatrixSymbol The matrix symbol whose eigen values are to be considered. Returns ======= Lambda Examples ======== >>> from sympy.stats import GaussianUnitaryEnsemble as GUE >>> from sympy.stats import joint_eigen_distribution >>> U = GUE('U', 2) >>> joint_eigen_dsitribution(U) Lambda((l[1], l[2]), exp(-l[1]2 - l[2]*2)Product(Abs(l[_i] - l[_j])*2, (_j, _i + 1, 2), (_i, 1, 1))/pi)""" (definition of level_spacing_distribution:) def level_spacing_distribution(mat): """For obtaining distribution of level spacings. Parameters ========== mat: RandomMatrixSymbol The random matrix symbol whose eigen values are to be considered for finding the level spacings. Returns ======= Lambda Examples ======== >>> from sympy.stats import GaussianUnitaryEnsemble as GUE >>> from sympy.stats import level_spacing_distribution >>> U = GUE('U', 2) >>> level_spacing_distribution(U) Lambda(_s, 32_s*2exp(-4_s2/pi)/pi*2) References ========== .. [1] https://en.wikipedia.org/wiki/Random_matrix#Distribution_of_level_spacings""" [end of new definitions in sympy/stats/random_matrix_models.py] [start of new definitions in sympy/stats/rv.py] (definition of RandomMatrixSymbol:) class RandomMatrixSymbol(MatrixSymbol): (definition of RandomMatrixSymbol.__new__:) def __new__(cls, symbol, n, m, pspace=None): [end of new definitions in sympy/stats/rv.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
scrapy__scrapy-3862	3,862	scrapy/scrapy	null	ae4eab9843752e7cf75420a5d4f4fa58f8da8e50	2019-07-09T18:24:49Z	diff --git a/docs/topics/developer-tools.rst b/docs/topics/developer-tools.rst index 82857c9da90..dcf8af36523 100644 --- a/docs/topics/developer-tools.rst +++ b/docs/topics/developer-tools.rst @@ -252,9 +252,33 @@ If the handy ``has_next`` element is ``true`` (try loading `quotes.toscrape.com/api/quotes?page=10`_ in your browser or a page-number greater than 10), we increment the ``page`` attribute and ``yield`` a new request, inserting the incremented page-number -into our ``url``. +into our ``url``. -You can see that with a few inspections in the `Network`-tool we +.. _requests-from-curl: + +In more complex websites, it could be difficult to easily reproduce the +requests, as we could need to add ``headers`` or ``cookies`` to make it work. +In those cases you can export the requests in `cURL <https://curl.haxx.se/>`_ +format, by right-clicking on each of them in the network tool and using the +:meth:`~scrapy.http.Request.from_curl()` method to generate an equivalent +request:: + + from scrapy import Request + + request = Request.from_curl( + "curl 'http://quotes.toscrape.com/api/quotes?page=1' -H 'User-Agent: Mozil" + "la/5.0 (X11; Linux x86_64; rv:67.0) Gecko/20100101 Firefox/67.0' -H 'Acce" + "pt: /' -H 'Accept-Language: ca,en-US;q=0.7,en;q=0.3' --compressed -H 'X" + "-Requested-With: XMLHttpRequest' -H 'Proxy-Authorization: Basic QFRLLTAzM" + "zEwZTAxLTk5MWUtNDFiNC1iZWRmLTJjNGI4M2ZiNDBmNDpAVEstMDMzMTBlMDEtOTkxZS00MW" + "I0LWJlZGYtMmM0YjgzZmI0MGY0' -H 'Connection: keep-alive' -H 'Referer: http" + "://quotes.toscrape.com/scroll' -H 'Cache-Control: max-age=0'") + +Alternatively, if you want to know the arguments needed to recreate that +request you can use the :func:`scrapy.utils.curl.curl_to_request_kwargs` +function to get a dictionary with the equivalent arguments. + +As you can see, with a few inspections in the `Network`-tool we were able to easily replicate the dynamic requests of the scrolling functionality of the page. Crawling dynamic pages can be quite daunting and pages can be very complex, but it (mostly) boils down @@ -262,7 +286,7 @@ to identifying the correct request and replicating it in your spider. .. _Developer Tools: https://en.wikipedia.org/wiki/Web_development_tools .. _quotes.toscrape.com: http://quotes.toscrape.com -.. _quotes.toscrape.com/scroll: quotes.toscrape.com/scroll/ +.. _quotes.toscrape.com/scroll: http://quotes.toscrape.com/scroll .. _quotes.toscrape.com/api/quotes?page=10: http://quotes.toscrape.com/api/quotes?page=10 .. _has-class-extension: https://parsel.readthedocs.io/en/latest/usage.html#other-xpath-extensions diff --git a/docs/topics/dynamic-content.rst b/docs/topics/dynamic-content.rst index 8b5dacf5607..8334ddcecd3 100644 --- a/docs/topics/dynamic-content.rst +++ b/docs/topics/dynamic-content.rst @@ -85,6 +85,13 @@ It might be enough to yield a :class:`~scrapy.http.Request` with the same HTTP method and URL. However, you may also need to reproduce the body, headers and form parameters (see :class:`~scrapy.http.FormRequest`) of that request. +As all major browsers allow to export the requests in `cURL +<https://curl.haxx.se/>`_ format, Scrapy incorporates the method +:meth:`~scrapy.http.Request.from_curl()` to generate an equivalent +:class:`~scrapy.http.Request` from a cURL command. To get more information +visit :ref:`request from curl <requests-from-curl>` inside the network +tool section. + Once you get the expected response, you can :ref:`extract the desired data from it <topics-handling-response-formats>`. diff --git a/docs/topics/request-response.rst b/docs/topics/request-response.rst index 4e81ce878ef..9a5c65b0d18 100644 --- a/docs/topics/request-response.rst +++ b/docs/topics/request-response.rst @@ -194,6 +194,8 @@ Request objects copied by default (unless new values are given as arguments). See also :ref:`topics-request-response-ref-request-callback-arguments`. + .. automethod:: from_curl + .. _topics-request-response-ref-request-callback-arguments: Passing additional data to callback functions diff --git a/scrapy/http/request/__init__.py b/scrapy/http/request/__init__.py index f5935c4ef63..d09eaf8497f 100644 --- a/scrapy/http/request/__init__.py +++ b/scrapy/http/request/__init__.py @@ -12,6 +12,7 @@ from scrapy.utils.trackref import object_ref from scrapy.utils.url import escape_ajax from scrapy.http.common import obsolete_setter +from scrapy.utils.curl import curl_to_request_kwargs class Request(object_ref): @@ -103,3 +104,34 @@ def replace(self, args, kwargs): kwargs.setdefault(x, getattr(self, x)) cls = kwargs.pop('cls', self.__class__) return cls(args, kwargs) + + @classmethod + def from_curl(cls, curl_command, ignore_unknown_options=True, kwargs): + """Create a Request object from a string containing a `cURL + <https://curl.haxx.se/>`_ command. It populates the HTTP method, the + URL, the headers, the cookies and the body. It accepts the same + arguments as the :class:`Request` class, taking preference and + overriding the values of the same arguments contained in the cURL + command. + + Unrecognized options are ignored by default. To raise an error when + finding unknown options call this method by passing + ``ignore_unknown_options=False``. + + .. caution:: Using :meth:`from_curl` from :class:`~scrapy.http.Request` + subclasses, such as :class:`~scrapy.http.JSONRequest`, or + :class:`~scrapy.http.XmlRpcRequest`, as well as having + :ref:`downloader middlewares <topics-downloader-middleware>` + and + :ref:`spider middlewares <topics-spider-middleware>` + enabled, such as + :class:`~scrapy.downloadermiddlewares.defaultheaders.DefaultHeadersMiddleware`, + :class:`~scrapy.downloadermiddlewares.useragent.UserAgentMiddleware`, + or + :class:`~scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware`, + may modify the :class:`~scrapy.http.Request` object. + + """ + request_kwargs = curl_to_request_kwargs(curl_command, ignore_unknown_options) + request_kwargs.update(kwargs) + return cls(*request_kwargs) diff --git a/scrapy/utils/curl.py b/scrapy/utils/curl.py new file mode 100644 index 00000000000..b3fd0a497ff --- /dev/null +++ b/scrapy/utils/curl.py @@ -0,0 +1,95 @@ +import argparse +import warnings +from shlex import split + +from six.moves.http_cookies import SimpleCookie +from six.moves.urllib.parse import urlparse +from six import string_types, iteritems +from w3lib.http import basic_auth_header + + +class CurlParser(argparse.ArgumentParser): + def error(self, message): + error_msg = \ + 'There was an error parsing the curl command: {}'.format(message) + raise ValueError(error_msg) + + +curl_parser = CurlParser() +curl_parser.add_argument('url') +curl_parser.add_argument('-H', '--header', dest='headers', action='append') +curl_parser.add_argument('-X', '--request', dest='method', default='get') +curl_parser.add_argument('-d', '--data', dest='data') +curl_parser.add_argument('-u', '--user', dest='auth') + + +safe_to_ignore_arguments = [ + ['--compressed'], + # `--compressed` argument is not safe to ignore, but it's included here + # because the `HttpCompressionMiddleware` is enabled by default + ['-s', '--silent'], + ['-v', '--verbose'], + ['-#', '--progress-bar'] +] + +for argument in safe_to_ignore_arguments: + curl_parser.add_argument(argument, action='store_true') + + +def curl_to_request_kwargs(curl_command, ignore_unknown_options=True): + """Convert a cURL command syntax to Request kwargs. + + :param str curl_command: string containing the curl command + :param bool ignore_unknown_options: If true, only a warning is emitted when + cURL options are unknown. Otherwise raises an error. (default: True) + :return: dictionary of Request kwargs + """ + + curl_args = split(curl_command) + + if curl_args[0] != 'curl': + raise ValueError('A curl command must start with "curl"') + + parsed_args, argv = curl_parser.parse_known_args(curl_args[1:]) + + if argv: + msg = 'Unrecognized options: {}'.format(', '.join(argv)) + if ignore_unknown_options: + warnings.warn(msg) + else: + raise ValueError(msg) + + url = parsed_args.url + + # curl automatically prepends 'http' if the scheme is missing, but Request + # needs the scheme to work + parsed_url = urlparse(url) + if not parsed_url.scheme: + url = 'http://' + url + + result = {'method': parsed_args.method.upper(), 'url': url} + + headers = [] + cookies = {} + for header in parsed_args.headers or (): + name, val = header.split(':', 1) + name = name.strip() + val = val.strip() + if name.title() == 'Cookie': + for name, morsel in iteritems(SimpleCookie(val)): + cookies[name] = morsel.value + else: + headers.append((name, val)) + + if parsed_args.auth: + user, password = parsed_args.auth.split(':', 1) + headers.append(('Authorization', basic_auth_header(user, password))) + + if headers: + result['headers'] = headers + if cookies: + result['cookies'] = cookies + if parsed_args.data: + result['body'] = parsed_args.data + + return result	diff --git a/tests/test_http_request.py b/tests/test_http_request.py index 952e208de0a..60494d792e1 100644 --- a/tests/test_http_request.py +++ b/tests/test_http_request.py @@ -269,6 +269,82 @@ def a_function(): with self.assertRaises(TypeError): self.request_class('http://example.com', a_function, errback='a_function') + def test_from_curl(self): + # Note: more curated tests regarding curl conversion are in + # `test_utils_curl.py` + curl_command = ( + "curl 'http://httpbin.org/post' -X POST -H 'Cookie: _gauges_unique" + "_year=1; _gauges_unique=1; _gauges_unique_month=1; _gauges_unique" + "_hour=1; _gauges_unique_day=1' -H 'Origin: http://httpbin.org' -H" + " 'Accept-Encoding: gzip, deflate' -H 'Accept-Language: en-US,en;q" + "=0.9,ru;q=0.8,es;q=0.7' -H 'Upgrade-Insecure-Requests: 1' -H 'Use" + "r-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTM" + "L, like Gecko) Ubuntu Chromium/62.0.3202.75 Chrome/62.0.3202.75 S" + "afari/537.36' -H 'Content-Type: application /x-www-form-urlencode" + "d' -H 'Accept: text/html,application/xhtml+xml,application/xml;q=" + "0.9,image/webp,image/apng,/;q=0.8' -H 'Cache-Control: max-age=0" + "' -H 'Referer: http://httpbin.org/forms/post' -H 'Connection: kee" + "p-alive' --data 'custname=John+Smith&custtel=500&custemail=jsmith" + "%40example.org&size=small&topping=cheese&topping=onion&delivery=1" + "2%3A15&comments=' --compressed" + ) + r = self.request_class.from_curl(curl_command) + self.assertEqual(r.method, "POST") + self.assertEqual(r.url, "http://httpbin.org/post") + self.assertEqual(r.body, + b"custname=John+Smith&custtel=500&custemail=jsmith%40" + b"example.org&size=small&topping=cheese&topping=onion" + b"&delivery=12%3A15&comments=") + self.assertEqual(r.cookies, { + '_gauges_unique_year': '1', + '_gauges_unique': '1', + '_gauges_unique_month': '1', + '_gauges_unique_hour': '1', + '_gauges_unique_day': '1' + }) + self.assertEqual(r.headers, { + b'Origin': [b'http://httpbin.org'], + b'Accept-Encoding': [b'gzip, deflate'], + b'Accept-Language': [b'en-US,en;q=0.9,ru;q=0.8,es;q=0.7'], + b'Upgrade-Insecure-Requests': [b'1'], + b'User-Agent': [b'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.' + b'36 (KHTML, like Gecko) Ubuntu Chromium/62.0.3202' + b'.75 Chrome/62.0.3202.75 Safari/537.36'], + b'Content-Type': [b'application /x-www-form-urlencoded'], + b'Accept': [b'text/html,application/xhtml+xml,application/xml;q=0.' + b'9,image/webp,image/apng,/;q=0.8'], + b'Cache-Control': [b'max-age=0'], + b'Referer': [b'http://httpbin.org/forms/post'], + b'Connection': [b'keep-alive']}) + + def test_from_curl_with_kwargs(self): + r = self.request_class.from_curl( + 'curl -X PATCH "http://example.org"', + method="POST", + meta={'key': 'value'} + ) + self.assertEqual(r.method, "POST") + self.assertEqual(r.meta, {"key": "value"}) + + def test_from_curl_ignore_unknown_options(self): + # By default: it works and ignores the unknown options: --foo and -z + with warnings.catch_warnings(): # avoid warning when executing tests + warnings.simplefilter('ignore') + r = self.request_class.from_curl( + 'curl -X DELETE "http://example.org" --foo -z', + ) + self.assertEqual(r.method, "DELETE") + + # If `ignore_unknon_options` is set to `False` it raises an error with + # the unknown options: --foo and -z + self.assertRaises( + ValueError, + lambda: self.request_class.from_curl( + 'curl -X PATCH "http://example.org" --foo -z', + ignore_unknown_options=False, + ), + ) + class FormRequestTest(RequestTest): diff --git a/tests/test_utils_curl.py b/tests/test_utils_curl.py new file mode 100644 index 00000000000..c5655df7ee0 --- /dev/null +++ b/tests/test_utils_curl.py @@ -0,0 +1,211 @@ +import unittest +import warnings + +from six import assertRaisesRegex +from w3lib.http import basic_auth_header + +from scrapy import Request +from scrapy.utils.curl import curl_to_request_kwargs + + +class CurlToRequestKwargsTest(unittest.TestCase): + maxDiff = 5000 + + def _test_command(self, curl_command, expected_result): + result = curl_to_request_kwargs(curl_command) + self.assertEqual(result, expected_result) + try: + Request(*result) + except TypeError as e: + self.fail("Request kwargs are not correct {}".format(e)) + + def test_get(self): + curl_command = "curl http://example.org/" + expected_result = {"method": "GET", "url": "http://example.org/"} + self._test_command(curl_command, expected_result) + + def test_get_without_scheme(self): + curl_command = "curl www.example.org" + expected_result = {"method": "GET", "url": "http://www.example.org"} + self._test_command(curl_command, expected_result) + + def test_get_basic_auth(self): + curl_command = 'curl "https://api.test.com/" -u ' \ + '"some_username:some_password"' + expected_result = { + "method": "GET", + "url": "https://api.test.com/", + "headers": [ + ( + "Authorization", + basic_auth_header("some_username", "some_password") + ) + ], + } + self._test_command(curl_command, expected_result) + + def test_get_complex(self): + curl_command = ( + "curl 'http://httpbin.org/get' -H 'Accept-Encoding: gzip, deflate'" + " -H 'Accept-Language: en-US,en;q=0.9,ru;q=0.8,es;q=0.7' -H 'Upgra" + "de-Insecure-Requests: 1' -H 'User-Agent: Mozilla/5.0 (X11; Linux " + "x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Ubuntu Chromium/62" + ".0.3202.75 Chrome/62.0.3202.75 Safari/537.36' -H 'Accept: text/ht" + "ml,application/xhtml+xml,application/xml;q=0.9,image/webp,image/a" + "png,/;q=0.8' -H 'Referer: http://httpbin.org/' -H 'Cookie: _gau" + "ges_unique_year=1; _gauges_unique=1; _gauges_unique_month=1; _gau" + "ges_unique_hour=1; _gauges_unique_day=1' -H 'Connection: keep-ali" + "ve' --compressed" + ) + expected_result = { + "method": "GET", + "url": "http://httpbin.org/get", + "headers": [ + ("Accept-Encoding", "gzip, deflate"), + ("Accept-Language", "en-US,en;q=0.9,ru;q=0.8,es;q=0.7"), + ("Upgrade-Insecure-Requests", "1"), + ( + "User-Agent", + "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML" + ", like Gecko) Ubuntu Chromium/62.0.3202.75 Chrome/62.0.32" + "02.75 Safari/537.36", + ), + ( + "Accept", + "text/html,application/xhtml+xml,application/xml;q=0.9,ima" + "ge/webp,image/apng,/;q=0.8", + ), + ("Referer", "http://httpbin.org/"), + ("Connection", "keep-alive"), + ], + "cookies": { + '_gauges_unique_year': '1', + '_gauges_unique_hour': '1', + '_gauges_unique_day': '1', + '_gauges_unique': '1', + '_gauges_unique_month': '1' + }, + } + self._test_command(curl_command, expected_result) + + def test_post(self): + curl_command = ( + "curl 'http://httpbin.org/post' -X POST -H 'Cookie: _gauges_unique" + "_year=1; _gauges_unique=1; _gauges_unique_month=1; _gauges_unique" + "_hour=1; _gauges_unique_day=1' -H 'Origin: http://httpbin.org' -H" + " 'Accept-Encoding: gzip, deflate' -H 'Accept-Language: en-US,en;q" + "=0.9,ru;q=0.8,es;q=0.7' -H 'Upgrade-Insecure-Requests: 1' -H 'Use" + "r-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTM" + "L, like Gecko) Ubuntu Chromium/62.0.3202.75 Chrome/62.0.3202.75 S" + "afari/537.36' -H 'Content-Type: application/x-www-form-urlencoded" + "' -H 'Accept: text/html,application/xhtml+xml,application/xml;q=0" + ".9,image/webp,image/apng,/;q=0.8' -H 'Cache-Control: max-age=0'" + " -H 'Referer: http://httpbin.org/forms/post' -H 'Connection: keep" + "-alive' --data 'custname=John+Smith&custtel=500&custemail=jsmith%" + "40example.org&size=small&topping=cheese&topping=onion&delivery=12" + "%3A15&comments=' --compressed" + ) + expected_result = { + "method": "POST", + "url": "http://httpbin.org/post", + "body": "custname=John+Smith&custtel=500&custemail=jsmith%40exampl" + "e.org&size=small&topping=cheese&topping=onion&delivery=12" + "%3A15&comments=", + "cookies": { + '_gauges_unique_year': '1', + '_gauges_unique_hour': '1', + '_gauges_unique_day': '1', + '_gauges_unique': '1', + '_gauges_unique_month': '1' + }, + "headers": [ + ("Origin", "http://httpbin.org"), + ("Accept-Encoding", "gzip, deflate"), + ("Accept-Language", "en-US,en;q=0.9,ru;q=0.8,es;q=0.7"), + ("Upgrade-Insecure-Requests", "1"), + ( + "User-Agent", + "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML" + ", like Gecko) Ubuntu Chromium/62.0.3202.75 Chrome/62.0.32" + "02.75 Safari/537.36", + ), + ("Content-Type", "application/x-www-form-urlencoded"), + ( + "Accept", + "text/html,application/xhtml+xml,application/xml;q=0.9,ima" + "ge/webp,image/apng,/;q=0.8", + ), + ("Cache-Control", "max-age=0"), + ("Referer", "http://httpbin.org/forms/post"), + ("Connection", "keep-alive"), + ], + } + self._test_command(curl_command, expected_result) + + def test_patch(self): + curl_command = ( + 'curl "https://example.com/api/fake" -u "username:password" -H "Ac' + 'cept: application/vnd.go.cd.v4+json" -H "Content-Type: applicatio' + 'n/json" -X PATCH -d \'{"hostname": "agent02.example.com", "agent' + '_config_state": "Enabled", "resources": ["Java","Linux"], "enviro' + 'nments": ["Dev"]}\'' + ) + expected_result = { + "method": "PATCH", + "url": "https://example.com/api/fake", + "headers": [ + ("Accept", "application/vnd.go.cd.v4+json"), + ("Content-Type", "application/json"), + ("Authorization", basic_auth_header("username", "password")), + ], + "body": '{"hostname": "agent02.example.com", "agent_config_state"' + ': "Enabled", "resources": ["Java","Linux"], "environments' + '": ["Dev"]}', + } + self._test_command(curl_command, expected_result) + + def test_delete(self): + curl_command = 'curl -X "DELETE" https://www.url.com/page' + expected_result = { + "method": "DELETE", "url": "https://www.url.com/page" + } + self._test_command(curl_command, expected_result) + + def test_get_silent(self): + curl_command = 'curl --silent "www.example.com"' + expected_result = {"method": "GET", "url": "http://www.example.com"} + self.assertEqual(curl_to_request_kwargs(curl_command), expected_result) + + def test_too_few_arguments_error(self): + assertRaisesRegex( + self, + ValueError, + r"too few arguments\|the following arguments are required:\surl", + lambda: curl_to_request_kwargs("curl"), + ) + + def test_ignore_unknown_options(self): + # case 1: ignore_unknown_options=True: + with warnings.catch_warnings(): # avoid warning when executing tests + warnings.simplefilter('ignore') + curl_command = 'curl --bar --baz http://www.example.com' + expected_result = \ + {"method": "GET", "url": "http://www.example.com"} + self.assertEqual(curl_to_request_kwargs(curl_command), expected_result) + + # case 2: ignore_unknown_options=False (raise exception): + assertRaisesRegex( + self, + ValueError, + "Unrecognized options:.--bar.--baz", + lambda: curl_to_request_kwargs( + "curl --bar --baz http://www.example.com", + ignore_unknown_options=False + ), + ) + + def test_must_start_with_curl_error(self): + self.assertRaises( + ValueError, + lambda: curl_to_request_kwargs("carl -X POST http://example.org") + )	diff --git a/docs/topics/developer-tools.rst b/docs/topics/developer-tools.rst index 82857c9da90..dcf8af36523 100644 --- a/docs/topics/developer-tools.rst +++ b/docs/topics/developer-tools.rst @@ -252,9 +252,33 @@ If the handy ``has_next`` element is ``true`` (try loading `quotes.toscrape.com/api/quotes?page=10`_ in your browser or a page-number greater than 10), we increment the ``page`` attribute and ``yield`` a new request, inserting the incremented page-number -into our ``url``. +into our ``url``. -You can see that with a few inspections in the `Network`-tool we +.. _requests-from-curl: + +In more complex websites, it could be difficult to easily reproduce the +requests, as we could need to add ``headers`` or ``cookies`` to make it work. +In those cases you can export the requests in `cURL <https://curl.haxx.se/>`_ +format, by right-clicking on each of them in the network tool and using the +:meth:`~scrapy.http.Request.from_curl()` method to generate an equivalent +request:: + + from scrapy import Request + + request = Request.from_curl( + "curl 'http://quotes.toscrape.com/api/quotes?page=1' -H 'User-Agent: Mozil" + "la/5.0 (X11; Linux x86_64; rv:67.0) Gecko/20100101 Firefox/67.0' -H 'Acce" + "pt: /' -H 'Accept-Language: ca,en-US;q=0.7,en;q=0.3' --compressed -H 'X" + "-Requested-With: XMLHttpRequest' -H 'Proxy-Authorization: Basic QFRLLTAzM" + "zEwZTAxLTk5MWUtNDFiNC1iZWRmLTJjNGI4M2ZiNDBmNDpAVEstMDMzMTBlMDEtOTkxZS00MW" + "I0LWJlZGYtMmM0YjgzZmI0MGY0' -H 'Connection: keep-alive' -H 'Referer: http" + "://quotes.toscrape.com/scroll' -H 'Cache-Control: max-age=0'") + +Alternatively, if you want to know the arguments needed to recreate that +request you can use the :func:`scrapy.utils.curl.curl_to_request_kwargs` +function to get a dictionary with the equivalent arguments. + +As you can see, with a few inspections in the `Network`-tool we were able to easily replicate the dynamic requests of the scrolling functionality of the page. Crawling dynamic pages can be quite daunting and pages can be very complex, but it (mostly) boils down @@ -262,7 +286,7 @@ to identifying the correct request and replicating it in your spider. .. _Developer Tools: https://en.wikipedia.org/wiki/Web_development_tools .. _quotes.toscrape.com: http://quotes.toscrape.com -.. _quotes.toscrape.com/scroll: quotes.toscrape.com/scroll/ +.. _quotes.toscrape.com/scroll: http://quotes.toscrape.com/scroll .. _quotes.toscrape.com/api/quotes?page=10: http://quotes.toscrape.com/api/quotes?page=10 .. _has-class-extension: https://parsel.readthedocs.io/en/latest/usage.html#other-xpath-extensions diff --git a/docs/topics/dynamic-content.rst b/docs/topics/dynamic-content.rst index 8b5dacf5607..8334ddcecd3 100644 --- a/docs/topics/dynamic-content.rst +++ b/docs/topics/dynamic-content.rst @@ -85,6 +85,13 @@ It might be enough to yield a :class:`~scrapy.http.Request` with the same HTTP method and URL. However, you may also need to reproduce the body, headers and form parameters (see :class:`~scrapy.http.FormRequest`) of that request. +As all major browsers allow to export the requests in `cURL +<https://curl.haxx.se/>`_ format, Scrapy incorporates the method +:meth:`~scrapy.http.Request.from_curl()` to generate an equivalent +:class:`~scrapy.http.Request` from a cURL command. To get more information +visit :ref:`request from curl <requests-from-curl>` inside the network +tool section. + Once you get the expected response, you can :ref:`extract the desired data from it <topics-handling-response-formats>`. diff --git a/docs/topics/request-response.rst b/docs/topics/request-response.rst index 4e81ce878ef..9a5c65b0d18 100644 --- a/docs/topics/request-response.rst +++ b/docs/topics/request-response.rst @@ -194,6 +194,8 @@ Request objects copied by default (unless new values are given as arguments). See also :ref:`topics-request-response-ref-request-callback-arguments`. + .. automethod:: from_curl + .. _topics-request-response-ref-request-callback-arguments: Passing additional data to callback functions	[ { "components": [ { "doc": "Create a Request object from a string containing a `cURL\n<https://curl.haxx.se/>`_ command. It populates the HTTP method, the\nURL, the headers, the cookies and the body. It accepts the same\narguments as the :class:`Request` class, taking preference and\noverriding th...	[ "tests/test_http_request.py::RequestTest::test_ajax_url", "tests/test_http_request.py::RequestTest::test_body", "tests/test_http_request.py::RequestTest::test_callback_is_callable", "tests/test_http_request.py::RequestTest::test_copy", "tests/test_http_request.py::RequestTest::test_copy_inherited_classes", ...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG+1] Create Request from curl command This is a WIP, but I open this PR to discuss how to implement this feature. Based on: https://github.com/scrapy/scrapy/pull/2985 (abandoned) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in scrapy/http/request/__init__.py] (definition of Request.from_curl:) def from_curl(cls, curl_command, ignore_unknown_options=True, **kwargs): """Create a Request object from a string containing a `cURL <https://curl.haxx.se/>`_ command. It populates the HTTP method, the URL, the headers, the cookies and the body. It accepts the same arguments as the :class:`Request` class, taking preference and overriding the values of the same arguments contained in the cURL command. Unrecognized options are ignored by default. To raise an error when finding unknown options call this method by passing ``ignore_unknown_options=False``. .. caution:: Using :meth:`from_curl` from :class:`~scrapy.http.Request` subclasses, such as :class:`~scrapy.http.JSONRequest`, or :class:`~scrapy.http.XmlRpcRequest`, as well as having :ref:`downloader middlewares <topics-downloader-middleware>` and :ref:`spider middlewares <topics-spider-middleware>` enabled, such as :class:`~scrapy.downloadermiddlewares.defaultheaders.DefaultHeadersMiddleware`, :class:`~scrapy.downloadermiddlewares.useragent.UserAgentMiddleware`, or :class:`~scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware`, may modify the :class:`~scrapy.http.Request` object.""" [end of new definitions in scrapy/http/request/__init__.py] [start of new definitions in scrapy/utils/curl.py] (definition of CurlParser:) class CurlParser(argparse.ArgumentParser): (definition of CurlParser.error:) def error(self, message): (definition of curl_to_request_kwargs:) def curl_to_request_kwargs(curl_command, ignore_unknown_options=True): """Convert a cURL command syntax to Request kwargs. :param str curl_command: string containing the curl command :param bool ignore_unknown_options: If true, only a warning is emitted when cURL options are unknown. Otherwise raises an error. (default: True) :return: dictionary of Request kwargs""" [end of new definitions in scrapy/utils/curl.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		57a5460529ff71c42e4d0381265b1b512b1eb09b
sympy__sympy-17163	17,163	sympy/sympy	1.5	fa8328d1cd9e7af7c81fdef579e788038465b665	2019-07-07T16:09:54Z	diff --git a/sympy/stats/__init__.py b/sympy/stats/__init__.py index 5364fce2185d..a9e304e726e2 100644 --- a/sympy/stats/__init__.py +++ b/sympy/stats/__init__.py @@ -83,10 +83,13 @@ from . import stochastic_process_types from .stochastic_process_types import ( StochasticProcess, + ContinuousTimeStochasticProcess, DiscreteTimeStochasticProcess, DiscreteMarkovChain, TransitionMatrixOf, - StochasticStateSpaceOf + StochasticStateSpaceOf, + ContinuousMarkovChain, + GeneratorMatrixOf ) __all__.extend(stochastic_process_types.__all__) diff --git a/sympy/stats/rv.py b/sympy/stats/rv.py index 55cb363b7301..43250c1a4044 100644 --- a/sympy/stats/rv.py +++ b/sympy/stats/rv.py @@ -17,7 +17,7 @@ from sympy import (Basic, S, Expr, Symbol, Tuple, And, Add, Eq, lambdify, Equality, Lambda, sympify, Dummy, Ne, KroneckerDelta, - DiracDelta, Mul, Indexed) + DiracDelta, Mul, Indexed, Function) from sympy.core.compatibility import string_types from sympy.core.relational import Relational from sympy.logic.boolalg import Boolean @@ -275,13 +275,19 @@ def free_symbols(self): class RandomIndexedSymbol(RandomSymbol): def __new__(cls, idx_obj, pspace=None): - if not isinstance(idx_obj, Indexed): - raise TypeError("An indexed object is expected not %s"%(idx_obj)) + if not isinstance(idx_obj, (Indexed, Function)): + raise TypeError("An Function or Indexed object is expected not %s"%(idx_obj)) return Basic.__new__(cls, idx_obj, pspace) symbol = property(lambda self: self.args[0]) name = property(lambda self: str(self.args[0])) - key = property(lambda self: self.symbol.args[1]) + + @property + def key(self): + if isinstance(self.symbol, Indexed): + return self.symbol.args[1] + elif isinstance(self.symbol, Function): + return self.symbol.args[0] class ProductPSpace(PSpace): """ diff --git a/sympy/stats/stochastic_process_types.py b/sympy/stats/stochastic_process_types.py index 66f0a57edece..e31bb9ace802 100644 --- a/sympy/stats/stochastic_process_types.py +++ b/sympy/stats/stochastic_process_types.py @@ -1,10 +1,11 @@ from __future__ import print_function, division from sympy import (Symbol, Matrix, MatrixSymbol, S, Indexed, Basic, - Set, And, Eq, FiniteSet, ImmutableMatrix, - Lambda, Mul, Sum, Dummy, Lt, IndexedBase, - linsolve, eye, Or, Ne, Not, Intersection, - Expr) + Set, And, Tuple, Eq, FiniteSet, ImmutableMatrix, + nsimplify, Lambda, Mul, Sum, Dummy, Lt, IndexedBase, + linsolve, Piecewise, eye, Or, Ne, Not, Intersection, + Union, Expr, Function, sympify, Le, exp, cacheit, Gt, + Ge) from sympy.core.relational import Relational from sympy.logic.boolalg import Boolean from sympy.stats.joint_rv import JointDistributionHandmade, JointDistribution @@ -18,7 +19,9 @@ 'DiscreteTimeStochasticProcess', 'DiscreteMarkovChain', 'TransitionMatrixOf', - 'StochasticStateSpaceOf' + 'StochasticStateSpaceOf', + 'GeneratorMatrixOf', + 'ContinuousMarkovChain' ] def _set_converter(itr): @@ -171,6 +174,25 @@ def __getitem__(self, time): pspace_obj = StochasticPSpace(self.symbol, self) return RandomIndexedSymbol(idx_obj, pspace_obj) +class ContinuousTimeStochasticProcess(StochasticProcess): + """ + Base class for all continuous time stochastic process. + """ + def __call__(self, time): + """ + For indexing continuous time stochastic processes. + + Returns + ======= + + RandomIndexedSymbol + """ + if time not in self.index_set: + raise IndexError("%s is not in the index set of %s"%(time, self.symbol)) + func_obj = Function(self.symbol)(time) + pspace_obj = StochasticPSpace(self.symbol, self) + return RandomIndexedSymbol(func_obj, pspace_obj) + class TransitionMatrixOf(Boolean): """ Assumes that the matrix is the transition matrix @@ -187,11 +209,24 @@ def __new__(cls, process, matrix): process = property(lambda self: self.args[0]) matrix = property(lambda self: self.args[1]) +class GeneratorMatrixOf(TransitionMatrixOf): + """ + Assumes that the matrix is the generator matrix + of the process. + """ + + def __new__(cls, process, matrix): + if not isinstance(process, ContinuousMarkovChain): + raise ValueError("Currently only ContinuousMarkovChain " + "support GeneratorMatrixOf.") + matrix = _matrix_checks(matrix) + return Basic.__new__(cls, process, matrix) + class StochasticStateSpaceOf(Boolean): def __new__(cls, process, state_space): - if not isinstance(process, DiscreteMarkovChain): - raise ValueError("Currently only DiscreteMarkovChain " + if not isinstance(process, (DiscreteMarkovChain, ContinuousMarkovChain)): + raise ValueError("Currently only DiscreteMarkovChain and ContinuousMarkovChain " "support StochasticStateSpaceOf.") state_space = _set_converter(state_space) return Basic.__new__(cls, process, state_space) @@ -199,64 +234,21 @@ def __new__(cls, process, state_space): process = property(lambda self: self.args[0]) state_space = property(lambda self: self.args[1]) -class DiscreteMarkovChain(DiscreteTimeStochasticProcess): +class MarkovProcess(StochasticProcess): """ - Represents discrete Markov chain. - - Parameters - ========== - - sym: Symbol - state_space: Set - Optional, by default, S.Reals - trans_probs: Matrix/ImmutableMatrix/MatrixSymbol - Optional, by default, None - - Examples - ======== - - >>> from sympy.stats import DiscreteMarkovChain, TransitionMatrixOf - >>> from sympy import Matrix, MatrixSymbol, Eq - >>> from sympy.stats import P - >>> T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]]) - >>> Y = DiscreteMarkovChain("Y", [0, 1, 2], T) - >>> YS = DiscreteMarkovChain("Y") - >>> Y.state_space - {0, 1, 2} - >>> Y.transition_probabilities - Matrix([ - [0.5, 0.2, 0.3], - [0.2, 0.5, 0.3], - [0.2, 0.3, 0.5]]) - >>> TS = MatrixSymbol('T', 3, 3) - >>> P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TS)) - T[0, 2]T[1, 0] + T[1, 1]T[1, 2] + T[1, 2]T[2, 2] - >>> P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) - 0.36 + Contains methods that handle queries + common to Markov processes. """ - index_set = S.Naturals0 - - def __new__(cls, sym, state_space=S.Reals, trans_probs=None): - sym = _symbol_converter(sym) - state_space = _set_converter(state_space) - if trans_probs != None: - trans_probs = _matrix_checks(trans_probs) - return Basic.__new__(cls, sym, state_space, trans_probs) - - @property - def transition_probabilities(self): - """ - Transition probabilities of discrete Markov chain, - either an instance of Matrix or MatrixSymbol. - """ - return self.args[2] - def _extract_information(self, given_condition): """ Helper function to extract information, like, - transition probabilities, state space, etc. + transition matrix/generator matrix, state space, etc. """ - trans_probs, state_space = self.transition_probabilities, self.state_space + if isinstance(self, DiscreteMarkovChain): + trans_probs = self.transition_probabilities + elif isinstance(self, ContinuousMarkovChain): + trans_probs = self.generator_matrix + state_space = self.state_space if isinstance(given_condition, And): gcs = given_condition.args given_condition = S.true @@ -269,11 +261,13 @@ def _extract_information(self, given_condition): given_condition = given_condition & gc if isinstance(given_condition, TransitionMatrixOf): trans_probs = given_condition.matrix + given_condition = S.true if isinstance(given_condition, StochasticStateSpaceOf): state_space = given_condition.state_space + given_condition = S.true return trans_probs, state_space, given_condition - def _check_trans_probs(self, trans_probs): + def _check_trans_probs(self, trans_probs, row_sum=1): """ Helper function for checking the validity of transition probabilities. @@ -281,9 +275,9 @@ def _check_trans_probs(self, trans_probs): if not isinstance(trans_probs, MatrixSymbol): rows = trans_probs.tolist() for row in rows: - if (sum(row) - 1) != 0: - raise ValueError("Probabilities in a row must sum to 1. " - "If you are using Float or floats then please use Rational.") + if (sum(row) - row_sum) != 0: + raise ValueError("Values in a row must sum to %s. " + "If you are using Float or floats then please use Rational."%(row_sum)) def _work_out_state_space(self, state_space, given_condition, trans_probs): """ @@ -302,6 +296,7 @@ def _work_out_state_space(self, state_space, given_condition, trans_probs): state_space = FiniteSet([i for i in range(trans_probs.shape[0])]) return state_space + @cacheit def _preprocess(self, given_condition, evaluate): """ Helper function for pre-processing the information. @@ -321,13 +316,284 @@ def _preprocess(self, given_condition, evaluate): is_insufficient = True else: # checking transition probabilities - self._check_trans_probs(trans_probs) + if isinstance(self, DiscreteMarkovChain): + self._check_trans_probs(trans_probs, row_sum=1) + elif isinstance(self, ContinuousMarkovChain): + self._check_trans_probs(trans_probs, row_sum=0) # working out state space state_space = self._work_out_state_space(state_space, given_condition, trans_probs) return is_insufficient, trans_probs, state_space, given_condition + def probability(self, condition, given_condition=None, evaluate=True, *kwargs): + """ + Handles probability queries for Markov process. + + Parameters + ========== + + condition: Relational + given_condition: Relational/And + + Returns + ======= + Probability + If the information is not sufficient. + Expr + In all other cases. + + Note + ==== + Any information passed at the time of query overrides + any information passed at the time of object creation like + transition probabilities, state space. + Pass the transition matrix using TransitionMatrixOf, + generator matrix using GeneratorMatrixOf and state space + using StochasticStateSpaceOf in given_condition using & or And. + """ + check, mat, state_space, new_given_condition = \ + self._preprocess(given_condition, evaluate) + + if check: + return Probability(condition, new_given_condition) + + if isinstance(self, ContinuousMarkovChain): + trans_probs = self.transition_probabilities(mat) + elif isinstance(self, DiscreteMarkovChain): + trans_probs = mat + + if isinstance(condition, Relational): + rv, states = (list(condition.atoms(RandomIndexedSymbol))[0], condition.as_set()) + if isinstance(new_given_condition, And): + gcs = new_given_condition.args + else: + gcs = (new_given_condition, ) + grvs = new_given_condition.atoms(RandomIndexedSymbol) + + min_key_rv = None + for grv in grvs: + if grv.key <= rv.key: + min_key_rv = grv + if min_key_rv == None: + return Probability(condition) + + prob, gstate = dict(), None + for gc in gcs: + if gc.has(min_key_rv): + if gc.has(Probability): + p, gp = (gc.rhs, gc.lhs) if isinstance(gc.lhs, Probability) \ + else (gc.lhs, gc.rhs) + gr = gp.args[0] + gset = Intersection(gr.as_set(), state_space) + gstate = list(gset)[0] + prob[gset] = p + else: + _, gstate = (gc.lhs.key, gc.rhs) if isinstance(gc.lhs, RandomIndexedSymbol) \ + else (gc.rhs.key, gc.lhs) + + if any((k not in self.index_set) for k in (rv.key, min_key_rv.key)): + raise IndexError("The timestamps of the process are not in it's index set.") + states = Intersection(states, state_space) + for state in Union(states, FiniteSet(gstate)): + if Ge(state, mat.shape[0]) == True: + raise IndexError("No information is available for (%s, %s) in " + "transition probabilities of shape, (%s, %s). " + "State space is zero indexed." + %(gstate, state, mat.shape[0], mat.shape[1])) + if prob: + gstates = Union(prob.keys()) + if len(gstates) == 1: + gstate = list(gstates)[0] + gprob = list(prob.values())[0] + prob[gstates] = gprob + elif len(gstates) == len(state_space) - 1: + gstate = list(state_space - gstates)[0] + gprob = S(1) - sum(prob.values()) + prob[state_space - gstates] = gprob + else: + raise ValueError("Conflicting information.") + else: + gprob = S(1) + + if min_key_rv == rv: + return sum([prob[FiniteSet(state)] for state in states]) + if isinstance(self, ContinuousMarkovChain): + return gprob * sum([trans_probs(rv.key - min_key_rv.key).__getitem__((gstate, state)) + for state in states]) + if isinstance(self, DiscreteMarkovChain): + return gprob * sum([(trans_probs(rv.key - min_key_rv.key)).__getitem__((gstate, state)) + for state in states]) + + if isinstance(condition, Not): + expr = condition.args[0] + return S(1) - self.probability(expr, given_condition, evaluate, kwargs) + + if isinstance(condition, And): + compute_later, state2cond, conds = [], dict(), condition.args + for expr in conds: + if isinstance(expr, Relational): + ris = list(expr.atoms(RandomIndexedSymbol))[0] + if state2cond.get(ris, None) is None: + state2cond[ris] = S.true + state2cond[ris] &= expr + else: + compute_later.append(expr) + ris = [] + for ri in state2cond: + ris.append(ri) + cset = Intersection(state2cond[ri].as_set(), state_space) + if len(cset) == 0: + return S.Zero + state2cond[ri] = cset.as_relational(ri) + sorted_ris = sorted(ris, key=lambda ri: ri.key) + prod = self.probability(state2cond[sorted_ris[0]], given_condition, evaluate, *kwargs) + for i in range(1, len(sorted_ris)): + ri, prev_ri = sorted_ris[i], sorted_ris[i-1] + if not isinstance(state2cond[ri], Eq): + raise ValueError("The process is in multiple states at %s, unable to determine the probability."%(ri)) + mat_of = TransitionMatrixOf(self, mat) if isinstance(self, DiscreteMarkovChain) else GeneratorMatrixOf(self, mat) + prod = self.probability(state2cond[ri], state2cond[prev_ri] + & mat_of + & StochasticStateSpaceOf(self, state_space), + evaluate, *kwargs) + for expr in compute_later: + prod = self.probability(expr, given_condition, evaluate, kwargs) + return prod + + if isinstance(condition, Or): + return sum([self.probability(expr, given_condition, evaluate, kwargs) + for expr in condition.args]) + + raise NotImplementedError("Mechanism for handling (%s, %s) queries hasn't been " + "implemented yet."%(expr, condition)) + + def expectation(self, expr, condition=None, evaluate=True, *kwargs): + """ + Handles expectation queries for markov process. + + Parameters + ========== + + expr: RandomIndexedSymbol, Relational, Logic + Condition for which expectation has to be computed. Must + contain a RandomIndexedSymbol of the process. + condition: Relational, Logic + The given conditions under which computations should be done. + + Returns + ======= + + Expectation + Unevaluated object if computations cannot be done due to + insufficient information. + Expr + In all other cases when the computations are successful. + + Note + ==== + + Any information passed at the time of query overrides + any information passed at the time of object creation like + transition probabilities, state space. + + Pass the transition matrix using TransitionMatrixOf, + generator matrix using GeneratorMatrixOf and state space + using StochasticStateSpaceOf in given_condition using & or And. + """ + + check, mat, state_space, condition = \ + self._preprocess(condition, evaluate) + + if check: + return Expectation(expr, condition) + + if isinstance(self, ContinuousMarkovChain): + trans_probs = self.transition_probabilities(mat) + elif isinstance(self, DiscreteMarkovChain): + trans_probs = mat + + rvs = random_symbols(expr) + if isinstance(expr, Expr) and isinstance(condition, Eq) \ + and len(rvs) == 1: + # handle queries similar to E(f(X[i]), Eq(X[i-m], <some-state>)) + rv = list(rvs)[0] + lhsg, rhsg = condition.lhs, condition.rhs + if not isinstance(lhsg, RandomIndexedSymbol): + lhsg, rhsg = (rhsg, lhsg) + if rhsg not in self.state_space: + raise ValueError("%s state is not in the state space."%(rhsg)) + if rv.key < lhsg.key: + raise ValueError("Incorrect given condition is given, expectation " + "time %s < time %s"%(rv.key, rv.key)) + mat_of = TransitionMatrixOf(self, mat) if isinstance(self, DiscreteMarkovChain) else GeneratorMatrixOf(self, mat) + cond = condition & mat_of & \ + StochasticStateSpaceOf(self, state_space) + s = Dummy('s') + func = lambda s: self.probability(Eq(rv, s), cond)expr.subs(rv, s) + return sum([func(s) for s in state_space]) + + raise NotImplementedError("Mechanism for handling (%s, %s) queries hasn't been " + "implemented yet."%(expr, condition)) + +class DiscreteMarkovChain(DiscreteTimeStochasticProcess, MarkovProcess): + """ + Represents discrete time Markov chain. + + Parameters + ========== + + sym: Symbol/string_types + state_space: Set + Optional, by default, S.Reals + trans_probs: Matrix/ImmutableMatrix/MatrixSymbol + Optional, by default, None + + Examples + ======== + + >>> from sympy.stats import DiscreteMarkovChain, TransitionMatrixOf + >>> from sympy import Matrix, MatrixSymbol, Eq + >>> from sympy.stats import P + >>> T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]]) + >>> Y = DiscreteMarkovChain("Y", [0, 1, 2], T) + >>> YS = DiscreteMarkovChain("Y") + >>> Y.state_space + {0, 1, 2} + >>> Y.transition_probabilities + Matrix([ + [0.5, 0.2, 0.3], + [0.2, 0.5, 0.3], + [0.2, 0.3, 0.5]]) + >>> TS = MatrixSymbol('T', 3, 3) + >>> P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TS)) + T[0, 2]T[1, 0] + T[1, 1]T[1, 2] + T[1, 2]T[2, 2] + >>> P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) + 0.36 + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Markov_chain#Discrete-time_Markov_chain + .. [2] https://www.dartmouth.edu/~chance/teaching_aids/books_articles/probability_book/Chapter11.pdf + """ + index_set = S.Naturals0 + + def __new__(cls, sym, state_space=S.Reals, trans_probs=None): + sym = _symbol_converter(sym) + state_space = _set_converter(state_space) + if trans_probs != None: + trans_probs = _matrix_checks(trans_probs) + return Basic.__new__(cls, sym, state_space, trans_probs) + + @property + def transition_probabilities(self): + """ + Transition probabilities of discrete Markov chain, + either an instance of Matrix or MatrixSymbol. + """ + return self.args[2] + def _transient2transient(self): """ Computes the one step probabilities of transient @@ -432,186 +698,70 @@ def limiting_distribution(self): """ return self.fixed_row_vector() - def probability(self, condition, given_condition=None, evaluate=True, kwargs): - """ - Handles probability queries for discrete Markov chains. - - Parameters - ========== - - condition: Relational - given_condition: Relational/And - - Returns - ======= - - Probability - If the transition probabilities are not available - Expr - If the transition probabilities is MatrixSymbol or Matrix - - Note - ==== - - Any information passed at the time of query overrides - any information passed at the time of object creation like - transition probabilities, state space. - - Pass the transition matrix using TransitionMatrixOf and state space - using StochasticStateSpaceOf in given_condition using & or And. - """ - - check, trans_probs, state_space, given_condition = \ - self._preprocess(given_condition, evaluate) - - if check: - return Probability(condition, given_condition) - - if isinstance(condition, Eq) and \ - isinstance(given_condition, Eq) and \ - len(given_condition.atoms(RandomSymbol)) == 1: - # handles simple queries like P(Eq(X[i], dest_state), Eq(X[i], init_state)) - lhsc, rhsc = condition.lhs, condition.rhs - lhsg, rhsg = given_condition.lhs, given_condition.rhs - if not isinstance(lhsc, RandomIndexedSymbol): - lhsc, rhsc = (rhsc, lhsc) - if not isinstance(lhsg, RandomIndexedSymbol): - lhsg, rhsg = (rhsg, lhsg) - keyc, statec, keyg, stateg = (lhsc.key, rhsc, lhsg.key, rhsg) - if Lt(stateg, trans_probs.shape[0]) == False or Lt(statec, trans_probs.shape[1]) == False: - raise IndexError("No information is available for (%s, %s) in " - "transition probabilities of shape, (%s, %s). " - "State space is zero indexed." - %(stateg, statec, trans_probs.shape[0], trans_probs.shape[1])) - if keyc < keyg: - raise ValueError("Incorrect given condition is given, probability " - "of past state cannot be computed from future state.") - nsteptp = trans_probs(keyc - keyg) - if hasattr(nsteptp, "__getitem__"): - return nsteptp.__getitem__((stateg, statec)) - return Indexed(nsteptp, stateg, statec) - - info = TransitionMatrixOf(self, trans_probs) & StochasticStateSpaceOf(self, state_space) - new_gc = given_condition & info - - if isinstance(condition, And): - # handle queries like, - # P(Eq(X[i+k], s1) & Eq(X[i+m], s2) . . . & Eq(X[i], sn), Eq(P(Eq(X[i], si)), prob)) - conds = condition.args - idx2state = dict() - for cond in conds: - idx, state = (cond.lhs, cond.rhs) if isinstance(cond.lhs, RandomIndexedSymbol) else \ - (cond.rhs, cond.lhs) - idx2state[idx] = cond if idx2state.get(idx, None) is None else \ - idx2state[idx] & cond - if any(len(Intersection(idx2state[idx].as_set(), state_space)) != 1 - for idx in idx2state): - return S.Zero # a RandomIndexedSymbol cannot go to different states simultaneously - i, result = -1, 1 - conds = And.fromiter(Intersection(idx2state[idx].as_set(), state_space).as_relational(idx) - for idx in idx2state) - if not isinstance(conds, And): - return self.probability(conds, new_gc) - conds = conds.args - while i > -len(conds): - result = self.probability(conds[i], conds[i-1] & info) - i -= 1 - if isinstance(given_condition, (TransitionMatrixOf, StochasticStateSpaceOf)): - return result * Probability(conds[i]) - if isinstance(given_condition, And): - idx_sym = conds[i].atoms(RandomIndexedSymbol) - prob, count = S(0), 0 - for gc in given_condition.args: - if gc.atoms(RandomIndexedSymbol) == idx_sym: - prob += gc.rhs if isinstance(gc.lhs, Probability) else gc.lhs - count += 1 - if isinstance(state_space, FiniteSet) and \ - count == len(state_space) - 1: - given_condition = Eq(Probability(conds[i]), S(1) - prob) - if isinstance(given_condition, Eq): - if not isinstance(given_condition.lhs, Probability) or \ - given_condition.lhs.args[0] != conds[i]: - raise ValueError("Probability for %s needed", conds[i]) - return result * given_condition.rhs - - if isinstance(condition, Or): - conds, prob_sum = condition.args, S(0) - idx2state = dict() - for cond in conds: - idx, state = (cond.lhs, cond.rhs) if isinstance(cond.lhs, RandomIndexedSymbol) else \ - (cond.rhs, cond.lhs) - idx2state[idx] = cond if idx2state.get(idx, None) is None else \ - idx2state[idx] \| cond - conds = Or.fromiter(Intersection(idx2state[idx].as_set(), state_space).as_relational(idx) - for idx in idx2state) - if not isinstance(conds, Or): - return self.probability(conds, new_gc) - return sum([self.probability(cond, new_gc) for cond in conds.args]) - - if isinstance(condition, Ne): - prob = self.probability(Not(condition), new_gc) - return S(1) - prob - - raise NotImplementedError("Mechanism for handling (%s, %s) queries hasn't been " - "implemented yet."%(condition, given_condition)) - - def expectation(self, expr, condition=None, evaluate=True, *kwargs): - """ - Handles expectation queries for discrete markov chains. +class ContinuousMarkovChain(ContinuousTimeStochasticProcess, MarkovProcess): + """ + Represents continuous time Markov chain. - Parameters - ========== + Parameters + ========== - expr: RandomIndexedSymbol, Relational, Logic - Condition for which expectation has to be computed. Must - contain a RandomIndexedSymbol of the process. - condition: Relational, Logic - The given conditions under which computations should be done. + sym: Symbol/string_types + state_space: Set + Optional, by default, S.Reals + gen_mat: Matrix/ImmutableMatrix/MatrixSymbol + Optional, by default, None - Returns - ======= + Examples + ======== - Expectation - Unevaluated object if computations cannot be done due to - insufficient information. - Expr - In all other cases when the computations are successful. + >>> from sympy.stats import ContinuousMarkovChain + >>> from sympy import Matrix, S, MatrixSymbol + >>> G = Matrix([[-S(1), S(1)], [S(1), -S(1)]]) + >>> C = ContinuousMarkovChain('C', state_space=[0, 1], gen_mat=G) + >>> C.limiting_distribution() + Matrix([[1/2, 1/2]]) - Note - ==== - - Any information passed at the time of query overrides - any information passed at the time of object creation like - transition probabilities, state space. + References + ========== - Pass the transition matrix using TransitionMatrixOf and state space - using StochasticStateSpaceOf in given_condition using & or And. - """ + .. [1] https://en.wikipedia.org/wiki/Markov_chain#Continuous-time_Markov_chain + .. [2] http://u.math.biu.ac.il/~amirgi/CTMCnotes.pdf + """ + index_set = S.Reals - check, trans_probs, state_space, condition = \ - self._preprocess(condition, evaluate) + def __new__(cls, sym, state_space=S.Reals, gen_mat=None): + sym = _symbol_converter(sym) + state_space = _set_converter(state_space) + if gen_mat != None: + gen_mat = _matrix_checks(gen_mat) + return Basic.__new__(cls, sym, state_space, gen_mat) - if check: - return Expectation(expr, condition) + @property + def generator_matrix(self): + return self.args[2] - rvs = random_symbols(expr) - if isinstance(expr, Expr) and isinstance(condition, Eq) \ - and len(rvs) == 1: - # handle queries similar to E(f(X[i]), Eq(X[i-m], <some-state>)) - rv = list(rvs)[0] - lhsg, rhsg = condition.lhs, condition.rhs - if not isinstance(lhsg, RandomIndexedSymbol): - lhsg, rhsg = (rhsg, lhsg) - if rhsg not in self.state_space: - raise ValueError("%s state is not in the state space."%(rhsg)) - if rv.key < lhsg.key: - raise ValueError("Incorrect given condition is given, expectation " - "time %s < time %s"%(rv.key, rv.key)) - cond = condition & TransitionMatrixOf(self, trans_probs) & \ - StochasticStateSpaceOf(self, state_space) - s = Dummy('s') - func = Lambda(s, self.probability(Eq(rv, s), cond)expr.subs(rv, s)) - return Sum(func(s), (s, state_space.inf, state_space.sup)).doit() + @cacheit + def transition_probabilities(self, gen_mat=None): + t = Dummy('t') + if isinstance(gen_mat, (Matrix, ImmutableMatrix)) and \ + gen_mat.is_diagonalizable(): + # for faster computation use diagonalized generator matrix + Q, D = gen_mat.diagonalize() + return Lambda(t, Qexp(tD)Q.inv()) + if gen_mat != None: + return Lambda(t, exp(tgen_mat)) - raise NotImplementedError("Mechanism for handling (%s, %s) queries hasn't been " - "implemented yet."%(expr, condition)) + def limiting_distribution(self): + gen_mat = self.generator_matrix + if gen_mat == None: + return None + if isinstance(gen_mat, MatrixSymbol): + wm = MatrixSymbol('wm', 1, gen_mat.shape[0]) + return Lambda((wm, gen_mat), Eq(wmgen_mat, wm)) + w = IndexedBase('w') + wi = [w[i] for i in range(gen_mat.shape[0])] + wm = Matrix([wi]) + eqs = (wmgen_mat).tolist()[0] + eqs.append(sum(wi) - 1) + soln = list(linsolve(eqs, wi))[0] + return ImmutableMatrix([[sol for sol in soln]])	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 131bcd80a6c8..a2ad8d3fb2e3 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1563,16 +1563,30 @@ def test_sympy__stats__stochastic_process_types__StochasticProcess(): from sympy.stats.stochastic_process_types import StochasticProcess assert _test_args(StochasticProcess("Y", [1, 2, 3])) +def test_sympy__stats__stochastic_process_types__MarkovProcess(): + from sympy.stats.stochastic_process_types import MarkovProcess + assert _test_args(MarkovProcess("Y", [1, 2, 3])) + def test_sympy__stats__stochastic_process_types__DiscreteTimeStochasticProcess(): from sympy.stats.stochastic_process_types import DiscreteTimeStochasticProcess assert _test_args(DiscreteTimeStochasticProcess("Y", [1, 2, 3])) +def test_sympy__stats__stochastic_process_types__ContinuousTimeStochasticProcess(): + from sympy.stats.stochastic_process_types import ContinuousTimeStochasticProcess + assert _test_args(ContinuousTimeStochasticProcess("Y", [1, 2, 3])) + def test_sympy__stats__stochastic_process_types__TransitionMatrixOf(): from sympy.stats.stochastic_process_types import TransitionMatrixOf, DiscreteMarkovChain from sympy import MatrixSymbol DMC = DiscreteMarkovChain("Y") assert _test_args(TransitionMatrixOf(DMC, MatrixSymbol('T', 3, 3))) +def test_sympy__stats__stochastic_process_types__GeneratorMatrixOf(): + from sympy.stats.stochastic_process_types import GeneratorMatrixOf, ContinuousMarkovChain + from sympy import MatrixSymbol + DMC = ContinuousMarkovChain("Y") + assert _test_args(GeneratorMatrixOf(DMC, MatrixSymbol('T', 3, 3))) + def test_sympy__stats__stochastic_process_types__StochasticStateSpaceOf(): from sympy.stats.stochastic_process_types import StochasticStateSpaceOf, DiscreteMarkovChain from sympy import MatrixSymbol @@ -1584,6 +1598,11 @@ def test_sympy__stats__stochastic_process_types__DiscreteMarkovChain(): from sympy import MatrixSymbol assert _test_args(DiscreteMarkovChain("Y", [0, 1, 2], MatrixSymbol('T', 3, 3))) +def test_sympy__stats__stochastic_process_types__ContinuousMarkovChain(): + from sympy.stats.stochastic_process_types import ContinuousMarkovChain + from sympy import MatrixSymbol + assert _test_args(ContinuousMarkovChain("Y", [0, 1, 2], MatrixSymbol('T', 3, 3))) + def test_sympy__core__symbol__Dummy(): from sympy.core.symbol import Dummy assert _test_args(Dummy('t')) diff --git a/sympy/stats/tests/test_stochastic_process.py b/sympy/stats/tests/test_stochastic_process.py index 5da55684eb3f..2729856a171a 100644 --- a/sympy/stats/tests/test_stochastic_process.py +++ b/sympy/stats/tests/test_stochastic_process.py @@ -1,7 +1,7 @@ from sympy import (S, symbols, FiniteSet, Eq, Matrix, MatrixSymbol, Float, And, - ImmutableMatrix, Ne, Lt, Gt) + ImmutableMatrix, Ne, Lt, Gt, exp, Not) from sympy.stats import (DiscreteMarkovChain, P, TransitionMatrixOf, E, - StochasticStateSpaceOf, variance) + StochasticStateSpaceOf, variance, ContinuousMarkovChain) from sympy.stats.joint_rv import JointDistribution from sympy.stats.rv import RandomIndexedSymbol from sympy.stats.symbolic_probability import Probability, Expectation @@ -41,6 +41,8 @@ def test_DiscreteMarkovChain(): assert P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) == Float(0.36, 2) assert str(P(Eq(YS[3], 2), Eq(YS[1], 1))) == \ "T[0, 2]T[1, 0] + T[1, 1]T[1, 2] + T[1, 2]T[2, 2]" + assert P(Eq(YS[1], 1), Eq(YS[2], 2)) == Probability(Eq(YS[1], 1)) + assert P(Eq(YS[3], 3), Eq(YS[1], 1)) == S.Zero TO = Matrix([[0.25, 0.75, 0],[0, 0.25, 0.75],[0.75, 0, 0.25]]) assert P(Eq(Y[3], 2), Eq(Y[1], 1) & TransitionMatrixOf(Y, TO)).round(3) == Float(0.375, 3) assert E(Y[3], evaluate=False) == Expectation(Y[3]) @@ -49,8 +51,6 @@ def test_DiscreteMarkovChain(): raises(ValueError, lambda: str(P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TSO)))) raises(TypeError, lambda: DiscreteMarkovChain("Z", [0, 1, 2], symbols('M'))) raises(ValueError, lambda: DiscreteMarkovChain("Z", [0, 1, 2], MatrixSymbol('T', 3, 4))) - raises(IndexError, lambda: str(P(Eq(YS[3], 3), Eq(YS[1], 1)))) - raises(ValueError, lambda: str(P(Eq(YS[1], 1), Eq(YS[2], 2)))) raises(ValueError, lambda: E(Y[3], Eq(Y[2], 6))) raises(ValueError, lambda: E(Y[2], Eq(Y[3], 1))) @@ -65,7 +65,7 @@ def test_DiscreteMarkovChain(): StochasticStateSpaceOf(X, [0, 1, 2]) & TransitionMatrixOf(X, TO1)) == S(1)/4 assert P(Ne(X[1], 2) & Ne(X[1], 1), Eq(X[0], 2) & StochasticStateSpaceOf(X, [0, 1, 2]) & TransitionMatrixOf(X, TO1)) == S(0) - raises (ValueError, lambda: str(P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)), Eq(Y[1], 1)))) + assert P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)), Eq(Y[1], 1)) == 0.1Probability(Eq(Y[0], 0)) # testing properties of Markov chain TO2 = Matrix([[S(1), 0, 0],[S(1)/3, S(1)/3, S(1)/3],[0, S(1)/4, S(3)/4]]) @@ -92,7 +92,9 @@ def test_DiscreteMarkovChain(): assert Y6.absorbing_probabilites() == ImmutableMatrix([[S(3)/4, S(1)/4], [S(1)/2, S(1)/2], [S(1)/4, S(3)/4]]) # testing miscellaneous queries - T = Matrix([[S(1)/2, S(1)/4, S(1)/4], [S(1)/3, 0, S(2)/3], [S(1)/2, S(1)/2, 0]]) + T = Matrix([[S(1)/2, S(1)/4, S(1)/4], + [S(1)/3, 0, S(2)/3], + [S(1)/2, S(1)/2, 0]]) X = DiscreteMarkovChain('X', [0, 1, 2], T) assert P(Eq(X[1], 2) & Eq(X[2], 1) & Eq(X[3], 0), Eq(P(Eq(X[1], 0)), S(1)/4) & Eq(P(Eq(X[1], 1)), S(1)/4)) == S(1)/12 @@ -102,3 +104,33 @@ def test_DiscreteMarkovChain(): assert E(X[1]*2, Eq(X[0], 1)) == S(8)/3 assert variance(X[1], Eq(X[0], 1)) == S(8)/9 raises(ValueError, lambda: E(X[1], Eq(X[2], 1))) + +def test_ContinuousMarkovChain(): + T1 = Matrix([[S(-2), S(2), S(0)], + [S(0), S(-1), S(1)], + [S(3)/2, S(3)/2, S(-3)]]) + C1 = ContinuousMarkovChain('C', [0, 1, 2], T1) + assert C1.limiting_distribution() == ImmutableMatrix([[S(3)/19, S(12)/19, S(4)/19]]) + + T2 = Matrix([[-S(1), S(1), S(0)], [S(1), -S(1), S(0)], [S(0), S(1), -S(1)]]) + C2 = ContinuousMarkovChain('C', [0, 1, 2], T2) + A, t = C2.generator_matrix, symbols('t', positive=True) + assert C2.transition_probabilities(A)(t) == Matrix([[S(1)/2 + exp(-2t)/2, S(1)/2 - exp(-2t)/2, 0], + [S(1)/2 - exp(-2t)/2, S(1)/2 + exp(-2t)/2, 0], + [S(1)/2 - exp(-t) + exp(-2t)/2, S(1)/2 - exp(-2t)/2, exp(-t)]]) + assert P(Eq(C2(1), 1), Eq(C2(0), 1), evaluate=False) == Probability(Eq(C2(1), 1)) + assert P(Eq(C2(1), 1), Eq(C2(0), 1)) == exp(-2)/2 + S(1)/2 + assert P(Eq(C2(1), 0) & Eq(C2(2), 1) & Eq(C2(3), 1), + Eq(P(Eq(C2(1), 0)), S(1)/2)) == (S(1)/4 - exp(-2)/4)(exp(-2)/2 + S(1)/2) + assert P(Not(Eq(C2(1), 0) & Eq(C2(2), 1) & Eq(C2(3), 2)) \| + (Eq(C2(1), 0) & Eq(C2(2), 1) & Eq(C2(3), 2)), + Eq(P(Eq(C2(1), 0)), S(1)/4) & Eq(P(Eq(C2(1), 1)), S(1)/4)) == S(1) + assert E(C2(S(3)/2), Eq(C2(0), 2)) == -exp(-3)/2 + 2exp(-S(3)/2) + S(1)/2 + assert variance(C2(S(3)/2), Eq(C2(0), 1)) == ((S(1)/2 - exp(-3)/2)2(exp(-3)/2 + S(1)/2) + + (-S(1)/2 - exp(-3)/2)*2(S(1)/2 - exp(-3)/2)) + raises(KeyError, lambda: P(Eq(C2(1), 0), Eq(P(Eq(C2(1), 1)), S(1)/2))) + assert P(Eq(C2(1), 0), Eq(P(Eq(C2(5), 1)), S(1)/2)) == Probability(Eq(C2(1), 0)) + TS1 = MatrixSymbol('G', 3, 3) + CS1 = ContinuousMarkovChain('C', [0, 1, 2], TS1) + A = CS1.generator_matrix + assert CS1.transition_probabilities(A)(t) == exp(t*A)		[ { "components": [ { "doc": "", "lines": [ 286, 290 ], "name": "RandomIndexedSymbol.key", "signature": "def key(self):", "type": "function" } ], "file": "sympy/stats/rv.py" }, { "components": [ { "doc": ...	[ "test_sympy__stats__stochastic_process_types__MarkovProcess", "test_sympy__stats__stochastic_process_types__ContinuousTimeStochasticProcess", "test_sympy__stats__stochastic_process_types__GeneratorMatrixOf", "test_sympy__stats__stochastic_process_types__ContinuousMarkovChain", "test_DiscreteMarkovChain" ]	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added continuous time Markov chain <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> [1] http://u.math.biu.ac.il/~amirgi/CTMCnotes.pdf #### Brief description of what is fixed or changed Continuous time Markov chains have been added. The API is kept similar to `DiscreteMarkovChain`. #### Other comments ping @Upabjojr @sidhantnagpal #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * stats * `ContinuousMarkovChain` have been added to `sympy.stats` <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/rv.py] (definition of RandomIndexedSymbol.key:) def key(self): [end of new definitions in sympy/stats/rv.py] [start of new definitions in sympy/stats/stochastic_process_types.py] (definition of ContinuousTimeStochasticProcess:) class ContinuousTimeStochasticProcess(StochasticProcess): """Base class for all continuous time stochastic process.""" (definition of ContinuousTimeStochasticProcess.__call__:) def __call__(self, time): """For indexing continuous time stochastic processes. Returns ======= RandomIndexedSymbol""" (definition of GeneratorMatrixOf:) class GeneratorMatrixOf(TransitionMatrixOf): """Assumes that the matrix is the generator matrix of the process.""" (definition of GeneratorMatrixOf.__new__:) def __new__(cls, process, matrix): (definition of MarkovProcess:) class MarkovProcess(StochasticProcess): """Contains methods that handle queries common to Markov processes.""" (definition of MarkovProcess._extract_information:) def _extract_information(self, given_condition): """Helper function to extract information, like, transition matrix/generator matrix, state space, etc.""" (definition of MarkovProcess._check_trans_probs:) def _check_trans_probs(self, trans_probs, row_sum=1): """Helper function for checking the validity of transition probabilities.""" (definition of MarkovProcess._work_out_state_space:) def _work_out_state_space(self, state_space, given_condition, trans_probs): """Helper function to extract state space if there is a random symbol in the given condition.""" (definition of MarkovProcess._preprocess:) def _preprocess(self, given_condition, evaluate): """Helper function for pre-processing the information.""" (definition of MarkovProcess.probability:) def probability(self, condition, given_condition=None, evaluate=True, kwargs): """Handles probability queries for Markov process. Parameters ========== condition: Relational given_condition: Relational/And Returns ======= Probability If the information is not sufficient. Expr In all other cases. Note ==== Any information passed at the time of query overrides any information passed at the time of object creation like transition probabilities, state space. Pass the transition matrix using TransitionMatrixOf, generator matrix using GeneratorMatrixOf and state space using StochasticStateSpaceOf in given_condition using & or And.""" (definition of MarkovProcess.expectation:) def expectation(self, expr, condition=None, evaluate=True, kwargs): """Handles expectation queries for markov process. Parameters ========== expr: RandomIndexedSymbol, Relational, Logic Condition for which expectation has to be computed. Must contain a RandomIndexedSymbol of the process. condition: Relational, Logic The given conditions under which computations should be done. Returns ======= Expectation Unevaluated object if computations cannot be done due to insufficient information. Expr In all other cases when the computations are successful. Note ==== Any information passed at the time of query overrides any information passed at the time of object creation like transition probabilities, state space. Pass the transition matrix using TransitionMatrixOf, generator matrix using GeneratorMatrixOf and state space using StochasticStateSpaceOf in given_condition using & or And.""" (definition of ContinuousMarkovChain:) class ContinuousMarkovChain(ContinuousTimeStochasticProcess, MarkovProcess): """Represents continuous time Markov chain. Parameters ========== sym: Symbol/string_types state_space: Set Optional, by default, S.Reals gen_mat: Matrix/ImmutableMatrix/MatrixSymbol Optional, by default, None Examples ======== >>> from sympy.stats import ContinuousMarkovChain >>> from sympy import Matrix, S, MatrixSymbol >>> G = Matrix([[-S(1), S(1)], [S(1), -S(1)]]) >>> C = ContinuousMarkovChain('C', state_space=[0, 1], gen_mat=G) >>> C.limiting_distribution() Matrix([[1/2, 1/2]]) References ========== .. [1] https://en.wikipedia.org/wiki/Markov_chain#Continuous-time_Markov_chain .. [2] http://u.math.biu.ac.il/~amirgi/CTMCnotes.pdf""" (definition of ContinuousMarkovChain.__new__:) def __new__(cls, sym, state_space=S.Reals, gen_mat=None): (definition of ContinuousMarkovChain.generator_matrix:) def generator_matrix(self): (definition of ContinuousMarkovChain.transition_probabilities:) def transition_probabilities(self, gen_mat=None): (definition of ContinuousMarkovChain.limiting_distribution:) def limiting_distribution(self): [end of new definitions in sympy/stats/stochastic_process_types.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
scikit-learn__scikit-learn-14263	14,263	scikit-learn/scikit-learn	0.22	70aa46ae8e8f327924ace7b2d70cad7cbd01bf0b	2019-07-05T10:19:05Z	diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 30fc3b5102bc6..ad290ef187aef 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -903,6 +903,9 @@ details. metrics.mean_squared_log_error metrics.median_absolute_error metrics.r2_score + metrics.mean_poisson_deviance + metrics.mean_gamma_deviance + metrics.mean_tweedie_deviance Multilabel ranking metrics -------------------------- diff --git a/doc/modules/model_evaluation.rst b/doc/modules/model_evaluation.rst index 789ffa038f25d..e28d35d985dd8 100644 --- a/doc/modules/model_evaluation.rst +++ b/doc/modules/model_evaluation.rst @@ -91,6 +91,8 @@ Scoring Function 'neg_mean_squared_log_error' :func:`metrics.mean_squared_log_error` 'neg_median_absolute_error' :func:`metrics.median_absolute_error` 'r2' :func:`metrics.r2_score` +'neg_mean_poisson_deviance' :func:`metrics.mean_poisson_deviance` +'neg_mean_gamma_deviance' :func:`metrics.mean_gamma_deviance` ============================== ============================================= ================================== @@ -1957,6 +1959,76 @@ Here is a small example of usage of the :func:`r2_score` function:: for an example of R² score usage to evaluate Lasso and Elastic Net on sparse signals. + +.. _mean_tweedie_deviance: + +Mean Poisson, Gamma, and Tweedie deviances +------------------------------------------ +The :func:`mean_tweedie_deviance` function computes the `mean Tweedie +deviance error +<https://en.wikipedia.org/wiki/Tweedie_distribution#The_Tweedie_deviance>`_ +with power parameter `p`. This is a metric that elicits predicted expectation +values of regression targets. + +Following special cases exist, + +- when `p=0` it is equivalent to :func:`mean_squared_error`. +- when `p=1` it is equivalent to :func:`mean_poisson_deviance`. +- when `p=2` it is equivalent to :func:`mean_gamma_deviance`. + +If :math:`\hat{y}_i` is the predicted value of the :math:`i`-th sample, +and :math:`y_i` is the corresponding true value, then the mean Tweedie +deviance error (D) estimated over :math:`n_{\text{samples}}` is defined as + +.. math:: + + \text{D}(y, \hat{y}) = \frac{1}{n_\text{samples}} + \sum_{i=0}^{n_\text{samples} - 1} + \begin{cases} + (y_i-\hat{y}_i)^2, & \text{for }p=0\text{ (Normal)}\\ + 2(y_i \log(y/\hat{y}_i) + \hat{y}_i - y_i), & \text{for }p=1\text{ (Poisson)}\\ + 2(\log(\hat{y}_i/y_i) + y_i/\hat{y}_i - 1), & \text{for }p=2\text{ (Gamma)}\\ + 2\left(\frac{\max(y_i,0)^{2-p}}{(1-p)(2-p)}- + \frac{y\,\hat{y}^{1-p}_i}{1-p}+\frac{\hat{y}^{2-p}_i}{2-p}\right), + & \text{otherwise} + \end{cases} + +Tweedie deviance is a homogeneous function of degree ``2-p``. +Thus, Gamma distribution with `p=2` means that simultaneously scaling `y_true` +and `y_pred` has no effect on the deviance. For Poisson distribution `p=1` +the deviance scales linearly, and for Normal distribution (`p=0`), +quadratically. In general, the higher `p` the less weight is given to extreme +deviations between true and predicted targets. + +For instance, let's compare the two predictions 1.0 and 100 that are both +50% of their corresponding true value. + +The mean squared error (``p=0``) is very sensitive to the +prediction difference of the second point,:: + + >>> from sklearn.metrics import mean_tweedie_deviance + >>> mean_tweedie_deviance([1.0], [1.5], p=0) + 0.25 + >>> mean_tweedie_deviance([100.], [150.], p=0) + 2500.0 + +If we increase ``p`` to 1,:: + + >>> mean_tweedie_deviance([1.0], [1.5], p=1) + 0.18... + >>> mean_tweedie_deviance([100.], [150.], p=1) + 18.9... + +the difference in errors decreases. Finally, by setting, ``p=2``:: + + >>> mean_tweedie_deviance([1.0], [1.5], p=2) + 0.14... + >>> mean_tweedie_deviance([100.], [150.], p=2) + 0.14... + +we would get identical errors. The deviance when `p=2` is thus only +sensitive to relative errors. + .. _clustering_metrics: Clustering metrics diff --git a/doc/whats_new/v0.22.rst b/doc/whats_new/v0.22.rst index f2046cc6b64f1..527db6432462e 100644 --- a/doc/whats_new/v0.22.rst +++ b/doc/whats_new/v0.22.rst @@ -124,6 +124,14 @@ Changelog - \|Feature\| Added multiclass support to :func:`metrics.roc_auc_score`. :issue:`12789` by :user:`Kathy Chen <kathyxchen>`, :user:`Mohamed Maskani <maskani-moh>`, and :user:`Thomas Fan <thomasjpfan>`. + +- \|Feature\| Add :class:`metrics.mean_tweedie_deviance` measuring the + Tweedie deviance for a power parameter ``p``. Also add mean Poisson deviance + :class:`metrics.mean_poisson_deviance` and mean Gamma deviance + :class:`metrics.mean_gamma_deviance` that are special cases of the Tweedie + deviance for `p=1` and `p=2` respectively. + :pr:`13938` by :user:`Christian Lorentzen <lorentzenchr>` and + `Roman Yurchak`_. :mod:`sklearn.model_selection` .................. diff --git a/sklearn/metrics/__init__.py b/sklearn/metrics/__init__.py index 61ac2e5be4807..6f16713161f12 100644 --- a/sklearn/metrics/__init__.py +++ b/sklearn/metrics/__init__.py @@ -64,6 +64,9 @@ from .regression import mean_squared_log_error from .regression import median_absolute_error from .regression import r2_score +from .regression import mean_tweedie_deviance +from .regression import mean_poisson_deviance +from .regression import mean_gamma_deviance from .scorer import check_scoring @@ -110,6 +113,9 @@ 'mean_absolute_error', 'mean_squared_error', 'mean_squared_log_error', + 'mean_poisson_deviance', + 'mean_gamma_deviance', + 'mean_tweedie_deviance', 'median_absolute_error', 'multilabel_confusion_matrix', 'mutual_info_score', diff --git a/sklearn/metrics/regression.py b/sklearn/metrics/regression.py index bee377f132cf7..2cba3d31ec84a 100644 --- a/sklearn/metrics/regression.py +++ b/sklearn/metrics/regression.py @@ -19,10 +19,12 @@ # Manoj Kumar <manojkumarsivaraj334@gmail.com> # Michael Eickenberg <michael.eickenberg@gmail.com> # Konstantin Shmelkov <konstantin.shmelkov@polytechnique.edu> +# Christian Lorentzen <lorentzen.ch@googlemail.com> # License: BSD 3 clause import numpy as np +from scipy.special import xlogy import warnings from ..utils.validation import (check_array, check_consistent_length, @@ -38,11 +40,14 @@ "mean_squared_log_error", "median_absolute_error", "r2_score", - "explained_variance_score" + "explained_variance_score", + "mean_tweedie_deviance", + "mean_poisson_deviance", + "mean_gamma_deviance", ] -def _check_reg_targets(y_true, y_pred, multioutput): +def _check_reg_targets(y_true, y_pred, multioutput, dtype="numeric"): """Check that y_true and y_pred belong to the same regression task Parameters @@ -72,11 +77,13 @@ def _check_reg_targets(y_true, y_pred, multioutput): Custom output weights if ``multioutput`` is array-like or just the corresponding argument if ``multioutput`` is a correct keyword. + dtype: str or list, default="numeric" + the dtype argument passed to check_array """ check_consistent_length(y_true, y_pred) - y_true = check_array(y_true, ensure_2d=False) - y_pred = check_array(y_pred, ensure_2d=False) + y_true = check_array(y_true, ensure_2d=False, dtype=dtype) + y_pred = check_array(y_pred, ensure_2d=False, dtype=dtype) if y_true.ndim == 1: y_true = y_true.reshape((-1, 1)) @@ -609,3 +616,179 @@ def max_error(y_true, y_pred): if y_type == 'continuous-multioutput': raise ValueError("Multioutput not supported in max_error") return np.max(np.abs(y_true - y_pred)) + + +def mean_tweedie_deviance(y_true, y_pred, sample_weight=None, p=0): + """Mean Tweedie deviance regression loss. + + Read more in the :ref:`User Guide <mean_tweedie_deviance>`. + + Parameters + ---------- + y_true : array-like of shape (n_samples,) + Ground truth (correct) target values. + + y_pred : array-like of shape (n_samples,) + Estimated target values. + + sample_weight : array-like, shape (n_samples,), optional + Sample weights. + + p : float, optional + Tweedie power parameter. Either p ≤ 0 or p ≥ 1. + + The higher `p` the less weight is given to extreme + deviations between true and predicted targets. + + - p < 0: Extreme stable distribution. Requires: y_pred > 0. + - p = 0 : Normal distribution, output corresponds to + mean_squared_error. y_true and y_pred can be any real numbers. + - p = 1 : Poisson distribution. Requires: y_true ≥ 0 and y_pred > 0. + - 1 < p < 2 : Compound Poisson distribution. Requires: y_true ≥ 0 + and y_pred > 0. + - p = 2 : Gamma distribution. Requires: y_true > 0 and y_pred > 0. + - p = 3 : Inverse Gaussian distribution. Requires: y_true > 0 + and y_pred > 0. + - otherwise : Positive stable distribution. Requires: y_true > 0 + and y_pred > 0. + + Returns + ------- + loss : float + A non-negative floating point value (the best value is 0.0). + + Examples + -------- + >>> from sklearn.metrics import mean_tweedie_deviance + >>> y_true = [2, 0, 1, 4] + >>> y_pred = [0.5, 0.5, 2., 2.] + >>> mean_tweedie_deviance(y_true, y_pred, p=1) + 1.4260... + """ + y_type, y_true, y_pred, _ = _check_reg_targets( + y_true, y_pred, None, dtype=[np.float64, np.float32]) + if y_type == 'continuous-multioutput': + raise ValueError("Multioutput not supported in mean_tweedie_deviance") + check_consistent_length(y_true, y_pred, sample_weight) + + if sample_weight is not None: + sample_weight = column_or_1d(sample_weight) + sample_weight = sample_weight[:, np.newaxis] + + message = ("Mean Tweedie deviance error with p={} can only be used on " + .format(p)) + if p < 0: + # 'Extreme stable', y_true any realy number, y_pred > 0 + if (y_pred <= 0).any(): + raise ValueError(message + "strictly positive y_pred.") + dev = 2 * (np.power(np.maximum(y_true, 0), 2-p)/((1-p) * (2-p)) - + y_true * np.power(y_pred, 1-p)/(1-p) + + np.power(y_pred, 2-p)/(2-p)) + elif p == 0: + # Normal distribution, y_true and y_pred any real number + dev = (y_true - y_pred)*2 + elif p < 1: + raise ValueError("Tweedie deviance is only defined for p<=0 and " + "p>=1.") + elif p == 1: + # Poisson distribution, y_true >= 0, y_pred > 0 + if (y_true < 0).any() or (y_pred <= 0).any(): + raise ValueError(message + "non-negative y_true and strictly " + "positive y_pred.") + dev = 2 (xlogy(y_true, y_true/y_pred) - y_true + y_pred) + elif p == 2: + # Gamma distribution, y_true and y_pred > 0 + if (y_true <= 0).any() or (y_pred <= 0).any(): + raise ValueError(message + "strictly positive y_true and y_pred.") + dev = 2 * (np.log(y_pred/y_true) + y_true/y_pred - 1) + else: + if p < 2: + # 1 < p < 2 is Compound Poisson, y_true >= 0, y_pred > 0 + if (y_true < 0).any() or (y_pred <= 0).any(): + raise ValueError(message + "non-negative y_true and strictly " + "positive y_pred.") + else: + if (y_true <= 0).any() or (y_pred <= 0).any(): + raise ValueError(message + "strictly positive y_true and " + "y_pred.") + + dev = 2 * (np.power(y_true, 2-p)/((1-p) * (2-p)) - + y_true * np.power(y_pred, 1-p)/(1-p) + + np.power(y_pred, 2-p)/(2-p)) + + return np.average(dev, weights=sample_weight) + + +def mean_poisson_deviance(y_true, y_pred, sample_weight=None): + """Mean Poisson deviance regression loss. + + Poisson deviance is equivalent to the Tweedie deviance with + the power parameter `p=1`. + + Read more in the :ref:`User Guide <mean_tweedie_deviance>`. + + Parameters + ---------- + y_true : array-like of shape (n_samples,) + Ground truth (correct) target values. Requires y_true ≥ 0. + + y_pred : array-like of shape (n_samples,) + Estimated target values. Requires y_pred > 0. + + sample_weight : array-like, shape (n_samples,), optional + Sample weights. + + Returns + ------- + loss : float + A non-negative floating point value (the best value is 0.0). + + Examples + -------- + >>> from sklearn.metrics import mean_poisson_deviance + >>> y_true = [2, 0, 1, 4] + >>> y_pred = [0.5, 0.5, 2., 2.] + >>> mean_poisson_deviance(y_true, y_pred) + 1.4260... + """ + return mean_tweedie_deviance( + y_true, y_pred, sample_weight=sample_weight, p=1 + ) + + +def mean_gamma_deviance(y_true, y_pred, sample_weight=None): + """Mean Gamma deviance regression loss. + + Gamma deviance is equivalent to the Tweedie deviance with + the power parameter `p=2`. It is invariant to scaling of + the target variable, and mesures relative errors. + + Read more in the :ref:`User Guide <mean_tweedie_deviance>`. + + Parameters + ---------- + y_true : array-like of shape (n_samples,) + Ground truth (correct) target values. Requires y_true > 0. + + y_pred : array-like of shape (n_samples,) + Estimated target values. Requires y_pred > 0. + + sample_weight : array-like, shape (n_samples,), optional + Sample weights. + + Returns + ------- + loss : float + A non-negative floating point value (the best value is 0.0). + + Examples + -------- + >>> from sklearn.metrics import mean_gamma_deviance + >>> y_true = [2, 0.5, 1, 4] + >>> y_pred = [0.5, 0.5, 2., 2.] + >>> mean_gamma_deviance(y_true, y_pred) + 1.0568... + """ + return mean_tweedie_deviance( + y_true, y_pred, sample_weight=sample_weight, p=2 + ) diff --git a/sklearn/metrics/scorer.py b/sklearn/metrics/scorer.py index 9fe3ad9fba4e1..5d543a305239b 100644 --- a/sklearn/metrics/scorer.py +++ b/sklearn/metrics/scorer.py @@ -24,7 +24,8 @@ import numpy as np from . import (r2_score, median_absolute_error, max_error, mean_absolute_error, - mean_squared_error, mean_squared_log_error, accuracy_score, + mean_squared_error, mean_squared_log_error, + mean_tweedie_deviance, accuracy_score, f1_score, roc_auc_score, average_precision_score, precision_score, recall_score, log_loss, balanced_accuracy_score, explained_variance_score, @@ -492,9 +493,15 @@ def make_scorer(score_func, greater_is_better=True, needs_proba=False, greater_is_better=False) neg_mean_absolute_error_scorer = make_scorer(mean_absolute_error, greater_is_better=False) - neg_median_absolute_error_scorer = make_scorer(median_absolute_error, greater_is_better=False) +neg_mean_poisson_deviance_scorer = make_scorer( + mean_tweedie_deviance, p=1., greater_is_better=False +) + +neg_mean_gamma_deviance_scorer = make_scorer( + mean_tweedie_deviance, p=2., greater_is_better=False +) # Standard Classification Scores accuracy_scorer = make_scorer(accuracy_score) @@ -542,6 +549,8 @@ def make_scorer(score_func, greater_is_better=True, needs_proba=False, neg_mean_absolute_error=neg_mean_absolute_error_scorer, neg_mean_squared_error=neg_mean_squared_error_scorer, neg_mean_squared_log_error=neg_mean_squared_log_error_scorer, + neg_mean_poisson_deviance=neg_mean_poisson_deviance_scorer, + neg_mean_gamma_deviance=neg_mean_gamma_deviance_scorer, accuracy=accuracy_scorer, roc_auc=roc_auc_scorer, roc_auc_ovr=roc_auc_ovr_scorer, roc_auc_ovo=roc_auc_ovo_scorer,	diff --git a/sklearn/metrics/tests/test_common.py b/sklearn/metrics/tests/test_common.py index 6442b11834671..8d62caa8a16c6 100644 --- a/sklearn/metrics/tests/test_common.py +++ b/sklearn/metrics/tests/test_common.py @@ -44,6 +44,9 @@ from sklearn.metrics import matthews_corrcoef from sklearn.metrics import mean_absolute_error from sklearn.metrics import mean_squared_error +from sklearn.metrics import mean_tweedie_deviance +from sklearn.metrics import mean_poisson_deviance +from sklearn.metrics import mean_gamma_deviance from sklearn.metrics import median_absolute_error from sklearn.metrics import multilabel_confusion_matrix from sklearn.metrics import precision_recall_curve @@ -97,6 +100,11 @@ "median_absolute_error": median_absolute_error, "explained_variance_score": explained_variance_score, "r2_score": partial(r2_score, multioutput='variance_weighted'), + "mean_normal_deviance": partial(mean_tweedie_deviance, p=0), + "mean_poisson_deviance": mean_poisson_deviance, + "mean_gamma_deviance": mean_gamma_deviance, + "mean_compound_poisson_deviance": + partial(mean_tweedie_deviance, p=1.4), } CLASSIFICATION_METRICS = { @@ -434,7 +442,7 @@ def precision_recall_curve_padded_thresholds(args, kwargs): "matthews_corrcoef_score", "mean_absolute_error", "mean_squared_error", "median_absolute_error", "max_error", - "cohen_kappa_score", + "cohen_kappa_score", "mean_normal_deviance" } # Asymmetric with respect to their input arguments y_true and y_pred @@ -456,7 +464,9 @@ def precision_recall_curve_padded_thresholds(args, *kwargs): "unnormalized_multilabel_confusion_matrix", "macro_f0.5_score", "macro_f2_score", "macro_precision_score", - "macro_recall_score", "log_loss", "hinge_loss" + "macro_recall_score", "log_loss", "hinge_loss", + "mean_gamma_deviance", "mean_poisson_deviance", + "mean_compound_poisson_deviance" } @@ -468,16 +478,22 @@ def precision_recall_curve_padded_thresholds(args, *kwargs): "weighted_ovo_roc_auc" } +METRICS_REQUIRE_POSITIVE_Y = { + "mean_poisson_deviance", + "mean_gamma_deviance", + "mean_compound_poisson_deviance", +} -@ignore_warnings -def test_symmetry(): - # Test the symmetry of score and loss functions - random_state = check_random_state(0) - y_true = random_state.randint(0, 2, size=(20, )) - y_pred = random_state.randint(0, 2, size=(20, )) - y_true_bin = random_state.randint(0, 2, size=(20, 25)) - y_pred_bin = random_state.randint(0, 2, size=(20, 25)) +def _require_positive_targets(y1, y2): + """Make targets strictly positive""" + offset = abs(min(y1.min(), y2.min())) + 1 + y1 += offset + y2 += offset + return y1, y2 + + +def test_symmetry_consistency(): # We shouldn't forget any metrics assert (SYMMETRIC_METRICS.union( @@ -489,29 +505,50 @@ def test_symmetry(): SYMMETRIC_METRICS.intersection(NOT_SYMMETRIC_METRICS) == set()) - # Symmetric metric - for name in SYMMETRIC_METRICS: - metric = ALL_METRICS[name] - if name in METRIC_UNDEFINED_BINARY: - if name in MULTILABELS_METRICS: - assert_allclose(metric(y_true_bin, y_pred_bin), - metric(y_pred_bin, y_true_bin), - err_msg="%s is not symmetric" % name) - else: - assert False, "This case is currently unhandled" - else: - assert_allclose(metric(y_true, y_pred), - metric(y_pred, y_true), + +@pytest.mark.parametrize("name", sorted(SYMMETRIC_METRICS)) +def test_symmetric_metric(name): + # Test the symmetry of score and loss functions + random_state = check_random_state(0) + y_true = random_state.randint(0, 2, size=(20, )) + y_pred = random_state.randint(0, 2, size=(20, )) + + if name in METRICS_REQUIRE_POSITIVE_Y: + y_true, y_pred = _require_positive_targets(y_true, y_pred) + + y_true_bin = random_state.randint(0, 2, size=(20, 25)) + y_pred_bin = random_state.randint(0, 2, size=(20, 25)) + + metric = ALL_METRICS[name] + if name in METRIC_UNDEFINED_BINARY: + if name in MULTILABELS_METRICS: + assert_allclose(metric(y_true_bin, y_pred_bin), + metric(y_pred_bin, y_true_bin), err_msg="%s is not symmetric" % name) + else: + assert False, "This case is currently unhandled" + else: + assert_allclose(metric(y_true, y_pred), + metric(y_pred, y_true), + err_msg="%s is not symmetric" % name) - # Not symmetric metrics - for name in NOT_SYMMETRIC_METRICS: - metric = ALL_METRICS[name] - # use context manager to supply custom error message - with assert_raises(AssertionError) as cm: - assert_array_equal(metric(y_true, y_pred), metric(y_pred, y_true)) - cm.msg = ("%s seems to be symmetric" % name) +@pytest.mark.parametrize("name", sorted(NOT_SYMMETRIC_METRICS)) +def test_not_symmetric_metric(name): + # Test the symmetry of score and loss functions + random_state = check_random_state(0) + y_true = random_state.randint(0, 2, size=(20, )) + y_pred = random_state.randint(0, 2, size=(20, )) + + if name in METRICS_REQUIRE_POSITIVE_Y: + y_true, y_pred = _require_positive_targets(y_true, y_pred) + + metric = ALL_METRICS[name] + + # use context manager to supply custom error message + with assert_raises(AssertionError) as cm: + assert_array_equal(metric(y_true, y_pred), metric(y_pred, y_true)) + cm.msg = ("%s seems to be symmetric" % name) @pytest.mark.parametrize( @@ -521,6 +558,9 @@ def test_sample_order_invariance(name): random_state = check_random_state(0) y_true = random_state.randint(0, 2, size=(20, )) y_pred = random_state.randint(0, 2, size=(20, )) + if name in METRICS_REQUIRE_POSITIVE_Y: + y_true, y_pred = _require_positive_targets(y_true, y_pred) + y_true_shuffle, y_pred_shuffle = shuffle(y_true, y_pred, random_state=0) with ignore_warnings(): @@ -574,6 +614,9 @@ def test_format_invariance_with_1d_vectors(name): y1 = random_state.randint(0, 2, size=(20, )) y2 = random_state.randint(0, 2, size=(20, )) + if name in METRICS_REQUIRE_POSITIVE_Y: + y1, y2 = _require_positive_targets(y1, y2) + y1_list = list(y1) y2_list = list(y2) @@ -762,7 +805,11 @@ def check_single_sample(name): metric = ALL_METRICS[name] # assert that no exception is thrown - for i, j in product([0, 1], repeat=2): + if name in METRICS_REQUIRE_POSITIVE_Y: + values = [1, 2] + else: + values = [0, 1] + for i, j in product(values, repeat=2): metric([i], [j]) diff --git a/sklearn/metrics/tests/test_regression.py b/sklearn/metrics/tests/test_regression.py index bc4cacb62e8d7..526c27f0a036c 100644 --- a/sklearn/metrics/tests/test_regression.py +++ b/sklearn/metrics/tests/test_regression.py @@ -1,5 +1,6 @@ import numpy as np +from numpy.testing import assert_allclose from itertools import product import pytest @@ -15,6 +16,7 @@ from sklearn.metrics import median_absolute_error from sklearn.metrics import max_error from sklearn.metrics import r2_score +from sklearn.metrics import mean_tweedie_deviance from sklearn.metrics.regression import _check_reg_targets @@ -34,6 +36,25 @@ def test_regression_metrics(n_samples=50): assert_almost_equal(max_error(y_true, y_pred), 1.) assert_almost_equal(r2_score(y_true, y_pred), 0.995, 2) assert_almost_equal(explained_variance_score(y_true, y_pred), 1.) + assert_almost_equal(mean_tweedie_deviance(y_true, y_pred, p=0), + mean_squared_error(y_true, y_pred)) + + # Tweedie deviance needs positive y_pred, except for p=0, + # p>=2 needs positive y_true + # results evaluated by sympy + y_true = np.arange(1, 1 + n_samples) + y_pred = 2 y_true + n = n_samples + assert_almost_equal(mean_tweedie_deviance(y_true, y_pred, p=-1), + 5/12 * n * (n*2 + 2 n + 1)) + assert_almost_equal(mean_tweedie_deviance(y_true, y_pred, p=1), + (n + 1) * (1 - np.log(2))) + assert_almost_equal(mean_tweedie_deviance(y_true, y_pred, p=2), + 2 * np.log(2) - 1) + assert_almost_equal(mean_tweedie_deviance(y_true, y_pred, p=3/2), + ((6 * np.sqrt(2) - 8) / n) * np.sqrt(y_true).sum()) + assert_almost_equal(mean_tweedie_deviance(y_true, y_pred, p=3), + np.sum(1 / y_true) / (4 * n)) def test_multioutput_regression(): @@ -75,6 +96,42 @@ def test_regression_metrics_at_limits(): "used when targets contain negative values.", mean_squared_log_error, [1., -2., 3.], [1., 2., 3.]) + # Tweedie deviance error + p = -1.2 + assert_allclose(mean_tweedie_deviance([0], [1.], p=p), + 2./(2.-p), rtol=1e-3) + with pytest.raises(ValueError, + match="can only be used on strictly positive y_pred."): + mean_tweedie_deviance([0.], [0.], p=p) + assert_almost_equal(mean_tweedie_deviance([0.], [0.], p=0), 0.00, 2) + + msg = "only be used on non-negative y_true and strictly positive y_pred." + with pytest.raises(ValueError, match=msg): + mean_tweedie_deviance([0.], [0.], p=1.0) + + p = 1.5 + assert_allclose(mean_tweedie_deviance([0.], [1.], p=p), 2./(2.-p)) + msg = "only be used on non-negative y_true and strictly positive y_pred." + with pytest.raises(ValueError, match=msg): + mean_tweedie_deviance([0.], [0.], p=p) + p = 2. + assert_allclose(mean_tweedie_deviance([1.], [1.], p=p), 0.00, + atol=1e-8) + msg = "can only be used on strictly positive y_true and y_pred." + with pytest.raises(ValueError, match=msg): + mean_tweedie_deviance([0.], [0.], p=p) + p = 3. + assert_allclose(mean_tweedie_deviance([1.], [1.], p=p), + 0.00, atol=1e-8) + + msg = "can only be used on strictly positive y_true and y_pred." + with pytest.raises(ValueError, match=msg): + mean_tweedie_deviance([0.], [0.], p=p) + + with pytest.raises(ValueError, + match="deviance is only defined for p<=0 and p>=1."): + mean_tweedie_deviance([0.], [0.], p=0.5) + def test__check_reg_targets(): # All of length 3 @@ -202,3 +259,29 @@ def test_regression_single_sample(metric): with pytest.warns(UndefinedMetricWarning, match=warning_msg): score = metric(y_true, y_pred) assert np.isnan(score) + + +def test_tweedie_deviance_continuity(): + n_samples = 100 + + y_true = np.random.RandomState(0).rand(n_samples) + 0.1 + y_pred = np.random.RandomState(1).rand(n_samples) + 0.1 + + assert_allclose(mean_tweedie_deviance(y_true, y_pred, p=0 - 1e-10), + mean_tweedie_deviance(y_true, y_pred, p=0)) + + # Ws we get closer to the limit, with 1e-12 difference the absolute + # tolerance to pass the below check increases. There are likely + # numerical precision issues on the edges of different definition + # regions. + assert_allclose(mean_tweedie_deviance(y_true, y_pred, p=1 + 1e-10), + mean_tweedie_deviance(y_true, y_pred, p=1), + atol=1e-6) + + assert_allclose(mean_tweedie_deviance(y_true, y_pred, p=2 - 1e-10), + mean_tweedie_deviance(y_true, y_pred, p=2), + atol=1e-6) + + assert_allclose(mean_tweedie_deviance(y_true, y_pred, p=2 + 1e-10), + mean_tweedie_deviance(y_true, y_pred, p=2), + atol=1e-6) diff --git a/sklearn/metrics/tests/test_score_objects.py b/sklearn/metrics/tests/test_score_objects.py index f7d41eda0075c..e4300125f57a3 100644 --- a/sklearn/metrics/tests/test_score_objects.py +++ b/sklearn/metrics/tests/test_score_objects.py @@ -43,7 +43,8 @@ 'neg_mean_squared_log_error', 'neg_median_absolute_error', 'mean_absolute_error', 'mean_squared_error', 'median_absolute_error', - 'max_error'] + 'max_error', 'neg_mean_poisson_deviance', + 'neg_mean_gamma_deviance'] CLF_SCORERS = ['accuracy', 'balanced_accuracy', 'f1', 'f1_weighted', 'f1_macro', 'f1_micro', @@ -67,11 +68,22 @@ MULTILABEL_ONLY_SCORERS = ['precision_samples', 'recall_samples', 'f1_samples', 'jaccard_samples'] +REQUIRE_POSITIVE_Y_SCORERS = ['neg_mean_poisson_deviance', + 'neg_mean_gamma_deviance'] + + +def _require_positive_y(y): + """Make targets strictly positive""" + offset = abs(y.min()) + 1 + y = y + offset + return y + def _make_estimators(X_train, y_train, y_ml_train): # Make estimators that make sense to test various scoring methods sensible_regr = DecisionTreeRegressor(random_state=0) - sensible_regr.fit(X_train, y_train) + # some of the regressions scorers require strictly positive input. + sensible_regr.fit(X_train, y_train + 1) sensible_clf = DecisionTreeClassifier(random_state=0) sensible_clf.fit(X_train, y_train) sensible_ml_clf = DecisionTreeClassifier(random_state=0) @@ -477,6 +489,8 @@ def test_scorer_sample_weight(): target = y_ml_test else: target = y_test + if name in REQUIRE_POSITIVE_Y_SCORERS: + target = _require_positive_y(target) try: weighted = scorer(estimator[name], X_test, target, sample_weight=sample_weight) @@ -498,22 +512,26 @@ def test_scorer_sample_weight(): "with sample weights: {1}".format(name, str(e))) -@ignore_warnings # UndefinedMetricWarning for P / R scores -def check_scorer_memmap(scorer_name): - scorer, estimator = SCORERS[scorer_name], ESTIMATORS[scorer_name] - if scorer_name in MULTILABEL_ONLY_SCORERS: - score = scorer(estimator, X_mm, y_ml_mm) - else: - score = scorer(estimator, X_mm, y_mm) - assert isinstance(score, numbers.Number), scorer_name - - @pytest.mark.parametrize('name', SCORERS) def test_scorer_memmap_input(name): # Non-regression test for #6147: some score functions would # return singleton memmap when computed on memmap data instead of scalar # float values. - check_scorer_memmap(name) + + if name in REQUIRE_POSITIVE_Y_SCORERS: + y_mm_1 = _require_positive_y(y_mm) + y_ml_mm_1 = _require_positive_y(y_ml_mm) + else: + y_mm_1, y_ml_mm_1 = y_mm, y_ml_mm + + # UndefinedMetricWarning for P / R scores + with ignore_warnings(): + scorer, estimator = SCORERS[name], ESTIMATORS[name] + if name in MULTILABEL_ONLY_SCORERS: + score = scorer(estimator, X_mm, y_ml_mm_1) + else: + score = scorer(estimator, X_mm, y_mm_1) + assert isinstance(score, numbers.Number), name def test_scoring_is_not_metric():	diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 30fc3b5102bc6..ad290ef187aef 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -903,6 +903,9 @@ details. metrics.mean_squared_log_error metrics.median_absolute_error metrics.r2_score + metrics.mean_poisson_deviance + metrics.mean_gamma_deviance + metrics.mean_tweedie_deviance Multilabel ranking metrics -------------------------- diff --git a/doc/modules/model_evaluation.rst b/doc/modules/model_evaluation.rst index 789ffa038f25d..e28d35d985dd8 100644 --- a/doc/modules/model_evaluation.rst +++ b/doc/modules/model_evaluation.rst @@ -91,6 +91,8 @@ Scoring Function 'neg_mean_squared_log_error' :func:`metrics.mean_squared_log_error` 'neg_median_absolute_error' :func:`metrics.median_absolute_error` 'r2' :func:`metrics.r2_score` +'neg_mean_poisson_deviance' :func:`metrics.mean_poisson_deviance` +'neg_mean_gamma_deviance' :func:`metrics.mean_gamma_deviance` ============================== ============================================= ================================== @@ -1957,6 +1959,76 @@ Here is a small example of usage of the :func:`r2_score` function:: for an example of R² score usage to evaluate Lasso and Elastic Net on sparse signals. + +.. _mean_tweedie_deviance: + +Mean Poisson, Gamma, and Tweedie deviances +------------------------------------------ +The :func:`mean_tweedie_deviance` function computes the `mean Tweedie +deviance error +<https://en.wikipedia.org/wiki/Tweedie_distribution#The_Tweedie_deviance>`_ +with power parameter `p`. This is a metric that elicits predicted expectation +values of regression targets. + +Following special cases exist, + +- when `p=0` it is equivalent to :func:`mean_squared_error`. +- when `p=1` it is equivalent to :func:`mean_poisson_deviance`. +- when `p=2` it is equivalent to :func:`mean_gamma_deviance`. + +If :math:`\hat{y}_i` is the predicted value of the :math:`i`-th sample, +and :math:`y_i` is the corresponding true value, then the mean Tweedie +deviance error (D) estimated over :math:`n_{\text{samples}}` is defined as + +.. math:: + + \text{D}(y, \hat{y}) = \frac{1}{n_\text{samples}} + \sum_{i=0}^{n_\text{samples} - 1} + \begin{cases} + (y_i-\hat{y}_i)^2, & \text{for }p=0\text{ (Normal)}\\ + 2(y_i \log(y/\hat{y}_i) + \hat{y}_i - y_i), & \text{for }p=1\text{ (Poisson)}\\ + 2(\log(\hat{y}_i/y_i) + y_i/\hat{y}_i - 1), & \text{for }p=2\text{ (Gamma)}\\ + 2\left(\frac{\max(y_i,0)^{2-p}}{(1-p)(2-p)}- + \frac{y\,\hat{y}^{1-p}_i}{1-p}+\frac{\hat{y}^{2-p}_i}{2-p}\right), + & \text{otherwise} + \end{cases} + +Tweedie deviance is a homogeneous function of degree ``2-p``. +Thus, Gamma distribution with `p=2` means that simultaneously scaling `y_true` +and `y_pred` has no effect on the deviance. For Poisson distribution `p=1` +the deviance scales linearly, and for Normal distribution (`p=0`), +quadratically. In general, the higher `p` the less weight is given to extreme +deviations between true and predicted targets. + +For instance, let's compare the two predictions 1.0 and 100 that are both +50% of their corresponding true value. + +The mean squared error (``p=0``) is very sensitive to the +prediction difference of the second point,:: + + >>> from sklearn.metrics import mean_tweedie_deviance + >>> mean_tweedie_deviance([1.0], [1.5], p=0) + 0.25 + >>> mean_tweedie_deviance([100.], [150.], p=0) + 2500.0 + +If we increase ``p`` to 1,:: + + >>> mean_tweedie_deviance([1.0], [1.5], p=1) + 0.18... + >>> mean_tweedie_deviance([100.], [150.], p=1) + 18.9... + +the difference in errors decreases. Finally, by setting, ``p=2``:: + + >>> mean_tweedie_deviance([1.0], [1.5], p=2) + 0.14... + >>> mean_tweedie_deviance([100.], [150.], p=2) + 0.14... + +we would get identical errors. The deviance when `p=2` is thus only +sensitive to relative errors. + .. _clustering_metrics: Clustering metrics diff --git a/doc/whats_new/v0.22.rst b/doc/whats_new/v0.22.rst index f2046cc6b64f1..527db6432462e 100644 --- a/doc/whats_new/v0.22.rst +++ b/doc/whats_new/v0.22.rst @@ -124,6 +124,14 @@ Changelog - \|Feature\| Added multiclass support to :func:`metrics.roc_auc_score`. :issue:`12789` by :user:`Kathy Chen <kathyxchen>`, :user:`Mohamed Maskani <maskani-moh>`, and :user:`Thomas Fan <thomasjpfan>`. + +- \|Feature\| Add :class:`metrics.mean_tweedie_deviance` measuring the + Tweedie deviance for a power parameter ``p``. Also add mean Poisson deviance + :class:`metrics.mean_poisson_deviance` and mean Gamma deviance + :class:`metrics.mean_gamma_deviance` that are special cases of the Tweedie + deviance for `p=1` and `p=2` respectively. + :pr:`13938` by :user:`Christian Lorentzen <lorentzenchr>` and + `Roman Yurchak`_. :mod:`sklearn.model_selection` ..................	[ { "components": [ { "doc": "Mean Tweedie deviance regression loss.\n\nRead more in the :ref:`User Guide <mean_tweedie_deviance>`.\n\nParameters\n----------\ny_true : array-like of shape (n_samples,)\n Ground truth (correct) target values.\n\ny_pred : array-like of shape (n_samples,)\n Estima...	[ "sklearn/metrics/tests/test_common.py::test_symmetry_consistency", "sklearn/metrics/tests/test_common.py::test_symmetric_metric[accuracy_score]", "sklearn/metrics/tests/test_common.py::test_symmetric_metric[cohen_kappa_score]", "sklearn/metrics/tests/test_common.py::test_symmetric_metric[f1_score]", "sklear...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> ENH Add Poisson, Gamma and Tweedie deviances to regression metrics ### Reference Issues/PRs Contributes to #9405 #### What does this implement/fix? Adds new regression metrics that are natural for GLMs. ### Comments Name ‘mean_teeedie_deviance_error‘ open for discussion ;-) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/metrics/regression.py] (definition of mean_tweedie_deviance:) def mean_tweedie_deviance(y_true, y_pred, sample_weight=None, p=0): """Mean Tweedie deviance regression loss. Read more in the :ref:`User Guide <mean_tweedie_deviance>`. Parameters ---------- y_true : array-like of shape (n_samples,) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) Estimated target values. sample_weight : array-like, shape (n_samples,), optional Sample weights. p : float, optional Tweedie power parameter. Either p ≤ 0 or p ≥ 1. The higher `p` the less weight is given to extreme deviations between true and predicted targets. - p < 0: Extreme stable distribution. Requires: y_pred > 0. - p = 0 : Normal distribution, output corresponds to mean_squared_error. y_true and y_pred can be any real numbers. - p = 1 : Poisson distribution. Requires: y_true ≥ 0 and y_pred > 0. - 1 < p < 2 : Compound Poisson distribution. Requires: y_true ≥ 0 and y_pred > 0. - p = 2 : Gamma distribution. Requires: y_true > 0 and y_pred > 0. - p = 3 : Inverse Gaussian distribution. Requires: y_true > 0 and y_pred > 0. - otherwise : Positive stable distribution. Requires: y_true > 0 and y_pred > 0. Returns ------- loss : float A non-negative floating point value (the best value is 0.0). Examples -------- >>> from sklearn.metrics import mean_tweedie_deviance >>> y_true = [2, 0, 1, 4] >>> y_pred = [0.5, 0.5, 2., 2.] >>> mean_tweedie_deviance(y_true, y_pred, p=1) 1.4260...""" (definition of mean_poisson_deviance:) def mean_poisson_deviance(y_true, y_pred, sample_weight=None): """Mean Poisson deviance regression loss. Poisson deviance is equivalent to the Tweedie deviance with the power parameter `p=1`. Read more in the :ref:`User Guide <mean_tweedie_deviance>`. Parameters ---------- y_true : array-like of shape (n_samples,) Ground truth (correct) target values. Requires y_true ≥ 0. y_pred : array-like of shape (n_samples,) Estimated target values. Requires y_pred > 0. sample_weight : array-like, shape (n_samples,), optional Sample weights. Returns ------- loss : float A non-negative floating point value (the best value is 0.0). Examples -------- >>> from sklearn.metrics import mean_poisson_deviance >>> y_true = [2, 0, 1, 4] >>> y_pred = [0.5, 0.5, 2., 2.] >>> mean_poisson_deviance(y_true, y_pred) 1.4260...""" (definition of mean_gamma_deviance:) def mean_gamma_deviance(y_true, y_pred, sample_weight=None): """Mean Gamma deviance regression loss. Gamma deviance is equivalent to the Tweedie deviance with the power parameter `p=2`. It is invariant to scaling of the target variable, and mesures relative errors. Read more in the :ref:`User Guide <mean_tweedie_deviance>`. Parameters ---------- y_true : array-like of shape (n_samples,) Ground truth (correct) target values. Requires y_true > 0. y_pred : array-like of shape (n_samples,) Estimated target values. Requires y_pred > 0. sample_weight : array-like, shape (n_samples,), optional Sample weights. Returns ------- loss : float A non-negative floating point value (the best value is 0.0). Examples -------- >>> from sklearn.metrics import mean_gamma_deviance >>> y_true = [2, 0.5, 1, 4] >>> y_pred = [0.5, 0.5, 2., 2.] >>> mean_gamma_deviance(y_true, y_pred) 1.0568...""" [end of new definitions in sklearn/metrics/regression.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c96e0958da46ebef482a4084cdda3285d5f5ad23
sympy__sympy-17153	17,153	sympy/sympy	1.5	40da07b3a8ca3b315aaf25ec4ac21dfe4364a097	2019-07-05T04:58:35Z	diff --git a/sympy/geometry/ellipse.py b/sympy/geometry/ellipse.py index 699064603461..2d56c2ad53bf 100644 --- a/sympy/geometry/ellipse.py +++ b/sympy/geometry/ellipse.py @@ -1336,6 +1336,7 @@ def vradius(self): """ return self.args[2] + def second_moment_of_area(self, point=None): """Returns the second moment and product moment area of an ellipse. @@ -1385,6 +1386,98 @@ def second_moment_of_area(self, point=None): return I_xx, I_yy, I_xy + def polar_second_moment_of_area(self): + """Returns the polar second moment of area of an Ellipse + + It is a constituent of the second moment of area, linked through + the perpendicular axis theorem. While the planar second moment of + area describes an object's resistance to deflection (bending) when + subjected to a force applied to a plane parallel to the central + axis, the polar second moment of area describes an object's + resistance to deflection when subjected to a moment applied in a + plane perpendicular to the object's central axis (i.e. parallel to + the cross-section) + + References + ========== + + https://en.wikipedia.org/wiki/Polar_moment_of_inertia + + Examples + ======== + + >>> from sympy import symbols, Circle, Ellipse + >>> c = Circle((5, 5), 4) + >>> c.polar_second_moment_of_area() + 128pi + >>> a, b = symbols('a, b') + >>> e = Ellipse((0, 0), a, b) + >>> e.polar_second_moment_of_area() + pia*3b/4 + piab*3/4 + """ + second_moment = self.second_moment_of_area() + return second_moment[0] + second_moment[1] + + + def section_modulus(self, point=None): + """Returns a tuple with the section modulus of an ellipse + + Section modulus is a geometric property of an ellipse defined as the + ratio of second moment of area to the distance of the extreme end of + the ellipse from the centroidal axis. + + References + ========== + + https://en.wikipedia.org/wiki/Section_modulus + + Parameters + ========== + + point : Point, two-tuple of sympifyable objects, or None(default=None) + point is the point at which section modulus is to be found. + If "point=None" section modulus will be calculated for the + point farthest from the centroidal axis of the ellipse. + + Returns + ======= + + S_x, S_y: numbers or SymPy expressions + S_x is the section modulus with respect to the x-axis + S_y is the section modulus with respect to the y-axis + A negetive sign indicates that the section modulus is + determined for a point below the centroidal axis. + + Examples + ======== + + >>> from sympy import Symbol, Ellipse, Circle, Point2D + >>> d = Symbol('d', positive=True) + >>> c = Circle((0, 0), d/2) + >>> c.section_modulus() + (pid*3/32, pid*3/32) + >>> e = Ellipse(Point2D(0, 0), 2, 4) + >>> e.section_modulus() + (8pi, 4pi) + """ + x_c, y_c = self.center + if point is None: + # taking x and y as maximum distances from centroid + x_min, y_min, x_max, y_max = self.bounds + y = max(y_c - y_min, y_max - y_c) + x = max(x_c - x_min, x_max - x_c) + else: + # taking x and y as distances of the given point from the center + y = point.y - y_c + x = point.x - x_c + + second_moment = self.second_moment_of_area() + S_x = second_moment[0]/y + S_y = second_moment[1]/x + + return S_x, S_y + + class Circle(Ellipse): """A circle in space. diff --git a/sympy/geometry/polygon.py b/sympy/geometry/polygon.py index 8dde50d1d0e4..3d7973c6fd85 100644 --- a/sympy/geometry/polygon.py +++ b/sympy/geometry/polygon.py @@ -381,7 +381,7 @@ def second_moment_of_area(self, point=None): Parameters ========== - point : Point, two-tuple of sympifiable objects, or None(default=None) + point : Point, two-tuple of sympifyable objects, or None(default=None) point is the point about which second moment of area is to be found. If "point=None" it will be calculated about the axis passing through the centroid of the polygon. @@ -413,7 +413,7 @@ def second_moment_of_area(self, point=None): """ I_xx, I_yy, I_xy = 0, 0, 0 - args = self.args + args = self.vertices for i in range(len(args)): x1, y1 = args[i-1].args x2, y2 = args[i].args @@ -438,6 +438,166 @@ def second_moment_of_area(self, point=None): return I_xx, I_yy, I_xy + def first_moment_of_area(self, point=None): + """ + Returns the first moment of area of a two-dimensional polygon with + respect to a certain point of interest. + + First moment of area is a measure of the distribution of the area + of a polygon in relation to an axis. The first moment of area of + the entire polygon about its own centroid is always zero. Therefore, + here it is calculated for an area, above or below a certain point + of interest, that makes up a smaller portion of the polygon. This + area is bounded by the point of interest and the extreme end + (top or bottom) of the polygon. The first moment for this area is + is then determined about the centroidal axis of the initial polygon. + + References + ========== + + https://skyciv.com/docs/tutorials/section-tutorials/calculating-the-statical-or-first-moment-of-area-of-beam-sections/?cc=BMD + https://mechanicalc.com/reference/cross-sections + + Parameters + ========== + + point: Point, two-tuple of sympifyable objects, or None (default=None) + point is the point above or below which the area of interest lies + If ``point=None`` then the centroid acts as the point of interest. + + Returns + ======= + + Q_x, Q_y: number or sympy expressions + Q_x is the first moment of area about the x-axis + Q_y is the first moment of area about the y-axis + A negetive sign indicates that the section modulus is + determined for a section below (or left of) the centroidal axis + + Examples + ======== + + >>> from sympy import Point, Polygon, symbol + >>> a, b = 50, 10 + >>> p1, p2, p3, p4 = [(0, b), (0, 0), (a, 0), (a, b)] + >>> p = Polygon(p1, p2, p3, p4) + >>> p.first_moment_of_area() + (625, 3125) + >>> p.first_moment_of_area(point=Point(30, 7)) + (525, 3000) + """ + if point: + xc, yc = self.centroid + else: + point = self.centroid + xc, yc = point + + h_line = Line(point, slope=0) + v_line = Line(point, slope=S.Infinity) + + h_poly = self.cut_section(h_line) + v_poly = self.cut_section(v_line) + + x_min, y_min, x_max, y_max = self.bounds + + poly_1 = h_poly[0] if h_poly[0].area <= h_poly[1].area else h_poly[1] + poly_2 = v_poly[0] if v_poly[0].area <= v_poly[1].area else v_poly[1] + + Q_x = (poly_1.centroid.y - yc)poly_1.area + Q_y = (poly_2.centroid.x - xc)poly_2.area + + return Q_x, Q_y + + + def polar_second_moment_of_area(self): + """Returns the polar modulus of a two-dimensional polygon + + It is a constituent of the second moment of area, linked through + the perpendicular axis theorem. While the planar second moment of + area describes an object's resistance to deflection (bending) when + subjected to a force applied to a plane parallel to the central + axis, the polar second moment of area describes an object's + resistance to deflection when subjected to a moment applied in a + plane perpendicular to the object's central axis (i.e. parallel to + the cross-section) + + References + ========== + + https://en.wikipedia.org/wiki/Polar_moment_of_inertia + + Examples + ======== + + >>> from sympy import Polygon, symbols + >>> a, b = symbols('a, b') + >>> rectangle = Polygon((0, 0), (a, 0), (a, b), (0, b)) + >>> rectangle.polar_second_moment_of_area() + a3b/12 + ab3/12 + """ + second_moment = self.second_moment_of_area() + return second_moment[0] + second_moment[1] + + + def section_modulus(self, point=None): + """Returns a tuple with the section modulus of a two-dimensional + polygon. + + Section modulus is a geometric property of a polygon defined as the + ratio of second moment of area to the distance of the extreme end of + the polygon from the centroidal axis. + + References + ========== + + https://en.wikipedia.org/wiki/Section_modulus + + Parameters + ========== + + point : Point, two-tuple of sympifyable objects, or None(default=None) + point is the point at which section modulus is to be found. + If "point=None" it will be calculated for the point farthest from the + centroidal axis of the polygon. + + Returns + ======= + + S_x, S_y: numbers or SymPy expressions + S_x is the section modulus with respect to the x-axis + S_y is the section modulus with respect to the y-axis + A negetive sign indicates that the section modulus is + determined for a point below the centroidal axis + + Examples + ======== + + >>> from sympy import symbols, Polygon, Point + >>> a, b = symbols('a, b', positive=True) + >>> rectangle = Polygon((0, 0), (a, 0), (a, b), (0, b)) + >>> rectangle.section_modulus() + (ab2/6, a2b/6) + >>> rectangle.section_modulus(Point(a/4, b/4)) + (-ab2/3, -a2*b/3) + """ + x_c, y_c = self.centroid + if point is None: + # taking x and y as maximum distances from centroid + x_min, y_min, x_max, y_max = self.bounds + y = max(y_c - y_min, y_max - y_c) + x = max(x_c - x_min, x_max - x_c) + else: + # taking x and y as distances of the given point from the centroid + y = point.y - y_c + x = point.x - x_c + + second_moment= self.second_moment_of_area() + S_x = second_moment[0]/y + S_y = second_moment[1]/x + + return S_x, S_y + + @property def sides(self): """The directed line segments that form the sides of the polygon. @@ -804,6 +964,11 @@ def cut_section(self, line): upper_polygon and lower polygon are ``None`` when no polygon exists above the line or below the line. + Raises + ====== + + ValueError: When the line does not intersect the polygon + References ========== @@ -832,7 +997,7 @@ def cut_section(self, line): if not intersection_points: raise ValueError("This line does not intersect the polygon") - points = self.vertices + points = list(self.vertices) points.append(points[0]) x, y = symbols('x, y', real=True, cls=Dummy)	diff --git a/sympy/geometry/tests/test_ellipse.py b/sympy/geometry/tests/test_ellipse.py index 1c3399136642..93b19ba629ca 100644 --- a/sympy/geometry/tests/test_ellipse.py +++ b/sympy/geometry/tests/test_ellipse.py @@ -1,4 +1,4 @@ -from sympy import Rational, S, Symbol, symbols, pi, sqrt, oo, Point2D, Segment2D, I +from sympy import Rational, S, Symbol, symbols, pi, sqrt, oo, Point2D, Segment2D, I, Abs from sympy.core.compatibility import range from sympy.geometry import (Circle, Ellipse, GeometryError, Line, Point, Polygon, Ray, RegularPolygon, Segment, Triangle, intersection) @@ -451,6 +451,28 @@ def test_second_moment_of_area(): assert I_xy == e.second_moment_of_area()[2] +def test_section_modulus_and_polar_second_moment_of_area(): + d = Symbol('d', positive=True) + c = Circle((3, 7), 8) + assert c.polar_second_moment_of_area() == 2048pi + assert c.section_modulus() == (128pi, 128pi) + c = Circle((2, 9), d/2) + assert c.polar_second_moment_of_area() == pid*3Abs(d)/64 + pidAbs(d)*3/64 + assert c.section_modulus() == (pid*3/S(32), pid*3/S(32)) + + a, b = symbols('a, b', positive=True) + e = Ellipse((4, 6), a, b) + assert e.section_modulus() == (piab2/S(4), pia*2b/S(4)) + assert e.polar_second_moment_of_area() == pia3b/S(4) + piab*3/S(4) + e = e.rotate(pi/2) # no change in polar and section modulus + assert e.section_modulus() == (pia*2b/S(4), piab*2/S(4)) + assert e.polar_second_moment_of_area() == pia*3b/S(4) + piab*3/S(4) + + e = Ellipse((a, b), 2, 6) + assert e.section_modulus() == (18pi, 6pi) + assert e.polar_second_moment_of_area() == 120pi + + def test_circumference(): M = Symbol('M') m = Symbol('m') diff --git a/sympy/geometry/tests/test_polygon.py b/sympy/geometry/tests/test_polygon.py index bcd6bcdc8a10..3f6c8793c982 100644 --- a/sympy/geometry/tests/test_polygon.py +++ b/sympy/geometry/tests/test_polygon.py @@ -524,6 +524,45 @@ def test_second_moment_of_area(): assert (I_xy - rectangle.second_moment_of_area(p)[2]) == 0 + r = RegularPolygon(Point(0, 0), 5, 3) + assert r.second_moment_of_area() == (1875sqrt(3)/S(32), 1875sqrt(3)/S(32), 0) + + +def test_first_moment(): + a, b = symbols('a, b', positive=True) + # rectangle + p1 = Polygon((0, 0), (a, 0), (a, b), (0, b)) + assert p1.first_moment_of_area() == (ab2/8, a2b/8) + assert p1.first_moment_of_area((a/3, b/4)) == (-3ab2/32, -a2b/9) + + p1 = Polygon((0, 0), (40, 0), (40, 30), (0, 30)) + assert p1.first_moment_of_area() == (4500, 6000) + + # triangle + p2 = Polygon((0, 0), (a, 0), (a/2, b)) + assert p2.first_moment_of_area() == (4ab2/81, a2b/24) + assert p2.first_moment_of_area((a/8, b/6)) == (-25ab*2/648, -5a*2b/768) + + p2 = Polygon((0, 0), (12, 0), (12, 30)) + p2.first_moment_of_area() == (1600/3, -640/3) + + +def test_section_modulus_and_polar_second_moment_of_area(): + a, b = symbols('a, b', positive=True) + x, y = symbols('x, y') + rectangle = Polygon((0, b), (0, 0), (a, 0), (a, b)) + assert rectangle.section_modulus(Point(x, y)) == (ab3/12/(-b/2 + y), a3b/12/(-a/2 + x)) + assert rectangle.polar_second_moment_of_area() == a*3b/12 + ab3/12 + + convex = RegularPolygon((0, 0), 1, 6) + assert convex.section_modulus() == (5/S(8), 5sqrt(3)/S(16)) + assert convex.polar_second_moment_of_area() == 5*sqrt(3)/S(8) + + concave = Polygon((0, 0), (1, 8), (3, 4), (4, 6), (7, 1)) + assert concave.section_modulus() == (-6371/S(429), -9778/S(519)) + assert concave.polar_second_moment_of_area() == -38669/S(252) + + def test_cut_section(): # concave polygon p = Polygon((-1, -1), (1, S(5)/2), (2, 1), (3, S(5)/2), (4, 2), (5, 3), (-1, 3))		[ { "components": [ { "doc": "Returns the polar second moment of area of an Ellipse\n\nIt is a constituent of the second moment of area, linked through\nthe perpendicular axis theorem. While the planar second moment of\narea describes an object's resistance to deflection (bending) when\nsubjected to...	[ "test_section_modulus_and_polar_second_moment_of_area", "test_second_moment_of_area", "test_first_moment" ]	[ "test_ellipse_equation_using_slope", "test_object_from_equation", "test_construction", "test_ellipse_random_point", "test_repr", "test_transform", "test_bounds", "test_reflect", "test_is_tangent", "test_parameter_value", "test_circumference", "test_issue_15259", "test_issue_15797_equals", ...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added functionality to determine polar second moment of area and section modulus of a polygon [Polar modulus](https://en.wikipedia.org/wiki/Polar_moment_of_inertia) and [section modulus](https://en.wikipedia.org/wiki/Section_modulus) are properties of a polygon (more specifically a cross-section). With `beam` module now accepting the cross-section (geometry object) as an alternative to the `second_moment`, this functionality would be of importance to the `beam` module, as it will be able to calculate the bending stresses and shear stresses on a beam with a particular cross-section This is in addition to previously implemented `second_moment_of_area()`. Also it takes a parameter `point` similar to that in the `second_moment_of_area()` ToDo's: - [x] Tests - [x] Documentation - [x] Implementing the same for Ellipses class - [x] method to calculate first moment of area (for polygon) #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - geometry - added methods in the polygon class to calculate section modulus, polar second moment of area and first moment of area of a two-dimensional polygon - added methods in the ellipse class to calculate section modulus and polar second moment of area of a two-dimensional ellipse <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/geometry/ellipse.py] (definition of Ellipse.polar_second_moment_of_area:) def polar_second_moment_of_area(self): """Returns the polar second moment of area of an Ellipse It is a constituent of the second moment of area, linked through the perpendicular axis theorem. While the planar second moment of area describes an object's resistance to deflection (bending) when subjected to a force applied to a plane parallel to the central axis, the polar second moment of area describes an object's resistance to deflection when subjected to a moment applied in a plane perpendicular to the object's central axis (i.e. parallel to the cross-section) References ========== https://en.wikipedia.org/wiki/Polar_moment_of_inertia Examples ======== >>> from sympy import symbols, Circle, Ellipse >>> c = Circle((5, 5), 4) >>> c.polar_second_moment_of_area() 128pi >>> a, b = symbols('a, b') >>> e = Ellipse((0, 0), a, b) >>> e.polar_second_moment_of_area() pia*3b/4 + piab*3/4""" (definition of Ellipse.section_modulus:) def section_modulus(self, point=None): """Returns a tuple with the section modulus of an ellipse Section modulus is a geometric property of an ellipse defined as the ratio of second moment of area to the distance of the extreme end of the ellipse from the centroidal axis. References ========== https://en.wikipedia.org/wiki/Section_modulus Parameters ========== point : Point, two-tuple of sympifyable objects, or None(default=None) point is the point at which section modulus is to be found. If "point=None" section modulus will be calculated for the point farthest from the centroidal axis of the ellipse. Returns ======= S_x, S_y: numbers or SymPy expressions S_x is the section modulus with respect to the x-axis S_y is the section modulus with respect to the y-axis A negetive sign indicates that the section modulus is determined for a point below the centroidal axis. Examples ======== >>> from sympy import Symbol, Ellipse, Circle, Point2D >>> d = Symbol('d', positive=True) >>> c = Circle((0, 0), d/2) >>> c.section_modulus() (pid*3/32, pid*3/32) >>> e = Ellipse(Point2D(0, 0), 2, 4) >>> e.section_modulus() (8pi, 4pi)""" [end of new definitions in sympy/geometry/ellipse.py] [start of new definitions in sympy/geometry/polygon.py] (definition of Polygon.first_moment_of_area:) def first_moment_of_area(self, point=None): """Returns the first moment of area of a two-dimensional polygon with respect to a certain point of interest. First moment of area is a measure of the distribution of the area of a polygon in relation to an axis. The first moment of area of the entire polygon about its own centroid is always zero. Therefore, here it is calculated for an area, above or below a certain point of interest, that makes up a smaller portion of the polygon. This area is bounded by the point of interest and the extreme end (top or bottom) of the polygon. The first moment for this area is is then determined about the centroidal axis of the initial polygon. References ========== https://skyciv.com/docs/tutorials/section-tutorials/calculating-the-statical-or-first-moment-of-area-of-beam-sections/?cc=BMD https://mechanicalc.com/reference/cross-sections Parameters ========== point: Point, two-tuple of sympifyable objects, or None (default=None) point is the point above or below which the area of interest lies If ``point=None`` then the centroid acts as the point of interest. Returns ======= Q_x, Q_y: number or sympy expressions Q_x is the first moment of area about the x-axis Q_y is the first moment of area about the y-axis A negetive sign indicates that the section modulus is determined for a section below (or left of) the centroidal axis Examples ======== >>> from sympy import Point, Polygon, symbol >>> a, b = 50, 10 >>> p1, p2, p3, p4 = [(0, b), (0, 0), (a, 0), (a, b)] >>> p = Polygon(p1, p2, p3, p4) >>> p.first_moment_of_area() (625, 3125) >>> p.first_moment_of_area(point=Point(30, 7)) (525, 3000)""" (definition of Polygon.polar_second_moment_of_area:) def polar_second_moment_of_area(self): """Returns the polar modulus of a two-dimensional polygon It is a constituent of the second moment of area, linked through the perpendicular axis theorem. While the planar second moment of area describes an object's resistance to deflection (bending) when subjected to a force applied to a plane parallel to the central axis, the polar second moment of area describes an object's resistance to deflection when subjected to a moment applied in a plane perpendicular to the object's central axis (i.e. parallel to the cross-section) References ========== https://en.wikipedia.org/wiki/Polar_moment_of_inertia Examples ======== >>> from sympy import Polygon, symbols >>> a, b = symbols('a, b') >>> rectangle = Polygon((0, 0), (a, 0), (a, b), (0, b)) >>> rectangle.polar_second_moment_of_area() a3b/12 + ab3/12""" (definition of Polygon.section_modulus:) def section_modulus(self, point=None): """Returns a tuple with the section modulus of a two-dimensional polygon. Section modulus is a geometric property of a polygon defined as the ratio of second moment of area to the distance of the extreme end of the polygon from the centroidal axis. References ========== https://en.wikipedia.org/wiki/Section_modulus Parameters ========== point : Point, two-tuple of sympifyable objects, or None(default=None) point is the point at which section modulus is to be found. If "point=None" it will be calculated for the point farthest from the centroidal axis of the polygon. Returns ======= S_x, S_y: numbers or SymPy expressions S_x is the section modulus with respect to the x-axis S_y is the section modulus with respect to the y-axis A negetive sign indicates that the section modulus is determined for a point below the centroidal axis Examples ======== >>> from sympy import symbols, Polygon, Point >>> a, b = symbols('a, b', positive=True) >>> rectangle = Polygon((0, 0), (a, 0), (a, b), (0, b)) >>> rectangle.section_modulus() (ab2/6, a2b/6) >>> rectangle.section_modulus(Point(a/4, b/4)) (-ab2/3, -a2*b/3)""" [end of new definitions in sympy/geometry/polygon.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-17145	17,145	sympy/sympy	1.5	12d8f5354db591ba6600c50f4188b7b973a859fc	2019-07-03T13:05:19Z	diff --git a/sympy/sets/fancysets.py b/sympy/sets/fancysets.py index 0d4804359b10..413fe1ab56b3 100644 --- a/sympy/sets/fancysets.py +++ b/sympy/sets/fancysets.py @@ -9,7 +9,7 @@ from sympy.core.singleton import Singleton, S from sympy.core.symbol import Dummy, symbols from sympy.core.sympify import _sympify, sympify, converter -from sympy.logic.boolalg import And +from sympy.logic.boolalg import And, Or from sympy.sets.sets import (Set, Interval, Union, FiniteSet, ProductSet, Intersection) from sympy.sets.contains import Contains @@ -766,6 +766,15 @@ def _sup(self): def _boundary(self): return self + def as_relational(self, x): + """Rewrite a Range in terms of equalities and logic operators. """ + from sympy.functions.elementary.integers import floor + i = (x - (self.inf if self.inf.is_finite else self.sup))/self.step + return And( + Eq(i, floor(i)), + x >= self.inf if self.inf in self else x > self.inf, + x <= self.sup if self.sup in self else x < self.sup) + if PY3: converter[range] = Range	diff --git a/sympy/sets/tests/test_fancysets.py b/sympy/sets/tests/test_fancysets.py index c952fc18caac..128618cc2517 100644 --- a/sympy/sets/tests/test_fancysets.py +++ b/sympy/sets/tests/test_fancysets.py @@ -309,6 +309,10 @@ def test_Range_set(): assert Range(builtin_range(1000000000000)) == \ Range(1000000000000) + # test Range.as_relational + assert Range(1, 4).as_relational(x) == (x >= 1) & (x <= 3) & Eq(x - 1, floor(x) - 1) + assert Range(oo, 1, -2).as_relational(x) == (x >= 3) & (x < oo) & Eq((3 - x)/2, floor((3 - x)/2)) + def test_range_range_intersection(): for a, b, r in [		[ { "components": [ { "doc": "Rewrite a Range in terms of equalities and logic operators. ", "lines": [ 769, 776 ], "name": "Range.as_relational", "signature": "def as_relational(self, x):", "type": "function" } ], "file": "sy...	[ "test_Range_set" ]	[ "test_naturals", "test_naturals0", "test_integers", "test_ImageSet", "test_image_is_ImageSet", "test_halfcircle", "test_ImageSet_iterator_not_injective", "test_inf_Range_len", "test_range_range_intersection", "test_range_interval_intersection", "test_Integers_eval_imageset", "test_Range_eval_i...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> as_relational added in Range <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed `as_relational` method has been added to `Range`. #### Other comments ping @Upabjojr @smichr #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * sets * `as_relational` has been added to `Range`. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/sets/fancysets.py] (definition of Range.as_relational:) def as_relational(self, x): """Rewrite a Range in terms of equalities and logic operators. """ [end of new definitions in sympy/sets/fancysets.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-17134	17,134	sympy/sympy	1.5	de86581abcec1e9a6018f22e95010809eaf7d2f0	2019-07-01T11:26:00Z	diff --git a/sympy/series/formal.py b/sympy/series/formal.py index c6a6f1a225fa..8b7a84421217 100644 --- a/sympy/series/formal.py +++ b/sympy/series/formal.py @@ -1052,6 +1052,9 @@ def truncate(self, n=6): return self.polynomial(n) + Order(pt_xk, (x, x0)) + def zero_coeff(self): + return self._eval_term(0) + def _eval_term(self, pt): try: pt_xk = self.xk.coeff(pt) @@ -1172,13 +1175,15 @@ def product(self, other, x=None, n=6): >>> f1 = fps(sin(x)) >>> f2 = fps(exp(x)) - >>> f1.product(f2, x, 4) + >>> f1.product(f2, x).truncate(4) x + x2 + x3/3 + O(x*4) See Also ======== sympy.discrete.convolutions + sympy.series.formal.FormalPowerSeriesProduct + """ if x is None: @@ -1202,20 +1207,7 @@ def product(self, other, x=None, n=6): elif self.x != other.x: raise ValueError("Both series should have the same symbol.") - k = self.ak.variables[0] - coeff1 = sequence(self.ak.formula, (k, 0, oo)) - - k = other.ak.variables[0] - coeff2 = sequence(other.ak.formula, (k, 0, oo)) - - conv_coeff = convolution(coeff1[:n], coeff2[:n]) - - conv_seq = sequence(tuple(conv_coeff), (k, 0, oo)) - k = self.xk.variables[0] - xk_seq = sequence(self.xk.formula, (k, 0, oo)) - terms_seq = xk_seq conv_seq - - return Add((terms_seq[:n])) + Order(self.xk.coeff(n), (self.x, self.x0)) + return FormalPowerSeriesProduct(self, other) def coeff_bell(self, n): r""" @@ -1275,16 +1267,17 @@ def compose(self, other, x=None, n=6): >>> f1 = fps(exp(x)) >>> f2 = fps(sin(x)) - >>> f1.compose(f2, x) + >>> f1.compose(f2, x).truncate() 1 + x + x2/2 - x4/8 - x5/15 + O(x6) - >>> f1.compose(f2, x, n=8) + >>> f1.compose(f2, x).truncate(8) 1 + x + x2/2 - x4/8 - x5/15 - x6/240 + x7/90 + O(x8) See Also ======== sympy.functions.combinatorial.numbers.bell + sympy.series.formal.FormalPowerSeriesCompose References ========== @@ -1314,19 +1307,11 @@ def compose(self, other, x=None, n=6): elif self.x != other.x: raise ValueError("Both series should have the same symbol.") - f, g = self.function, other.function if other._eval_term(0).as_coeff_mul(other.x)[0] is not S.Zero: raise ValueError("The formal power series of the inner function should not have any " "constant coefficient term.") - terms = [] - - for i in range(1, n): - bell_seq = other.coeff_bell(i) - seq = (self.bell_coeff_seq bell_seq) - terms.append(Add((seq[:i])) self.xk.coeff(i) / self.fact_seq[i-1]) - - return self._eval_term(0) + Add(terms) + Order(self.xk.coeff(n), (self.x, self.x0)) + return FormalPowerSeriesCompose(self, other) def inverse(self, x=None, n=6): r""" @@ -1356,16 +1341,17 @@ def inverse(self, x=None, n=6): >>> f1 = fps(exp(x)) >>> f2 = fps(cos(x)) - >>> f1.inverse(x) + >>> f1.inverse(x).truncate() 1 - x + x2/2 - x3/6 + x4/24 - x5/120 + O(x6) - >>> f2.inverse(x, n=8) + >>> f2.inverse(x).truncate(8) 1 + x2/2 + 5x*4/24 + 61x6/720 + O(x8) See Also ======== sympy.functions.combinatorial.numbers.bell + sympy.series.formal.FormalPowerSeriesInverse References ========== @@ -1379,23 +1365,11 @@ def inverse(self, x=None, n=6): if n is None: return iter(self) - f = self.function if self._eval_term(0) is S.Zero: raise ValueError("Constant coefficient should exist for an inverse of a formal" " power series to exist.") - inv = self._eval_term(0) - k = Dummy('k') - terms = [] - inv_seq = sequence(inv ** (-(k + 1)), (k, 1, oo)) - aux_seq = self.sign_seq * self.fact_seq * inv_seq - - for i in range(1, n): - bell_seq = self.coeff_bell(i) - seq = (aux_seq * bell_seq) - terms.append(Add((seq[:i])) self.xk.coeff(i) / self.fact_seq[i-1]) - - return self._eval_term(0) + Add(terms) + Order(self.xk.coeff(n), (self.x, self.x0)) + return FormalPowerSeriesInverse(self) def __add__(self, other): other = sympify(other) @@ -1464,6 +1438,280 @@ def __rmul__(self, other): return self.__mul__(other) +class FiniteFormalPowerSeries(FormalPowerSeries): + """Base Class for Product, Compose and Inverse classes""" + + def __init__(self, args): + pass + + @property + def ffps(self): + return self.args[0] + + @property + def gfps(self): + return self.args[1] + + @property + def f(self): + return self.ffps.function + + @property + def g(self): + return self.gfps.function + + @property + def infinite(self): + raise NotImplementedError("No infinite version for an object of" + " FiniteFormalPowerSeries class.") + + def _eval_terms(self, n): + raise NotImplementedError("(%s)._eval_terms()" % self) + + def _eval_term(self, pt): + raise NotImplementedError("By the current logic, one can get terms" + "upto a certain order, instead of getting term by term.") + + def polynomial(self, n): + return self._eval_terms(n) + + def truncate(self, n=6): + ffps = self.ffps + pt_xk = ffps.xk.coeff(n) + x, x0 = ffps.x, ffps.x0 + + return self.polynomial(n) + Order(pt_xk, (x, x0)) + + def _eval_derivative(self, x): + raise NotImplementedError + + def integrate(self, x): + raise NotImplementedError + + +class FormalPowerSeriesProduct(FiniteFormalPowerSeries): + """Represents the product of two formal power series of two functions. + + No computation is performed. Terms are calculated using a term by term logic, + instead of a point by point logic. + + There are two differences between a `FormalPowerSeries` object and a + `FormalPowerSeriesProduct` object. The first argument contains the two + functions involved in the product. Also, the coefficient sequence contains + both the coefficient sequence of the formal power series of the involved functions. + + See Also + ======== + + sympy.series.formal.FormalPowerSeries + sympy.series.formal.FiniteFormalPowerSeries + + """ + + def __init__(self, args): + ffps, gfps = self.ffps, self.gfps + + k = ffps.ak.variables[0] + self.coeff1 = sequence(ffps.ak.formula, (k, 0, oo)) + + k = gfps.ak.variables[0] + self.coeff2 = sequence(gfps.ak.formula, (k, 0, oo)) + + @property + def function(self): + """Function of the product of two formal power series.""" + return self.f self.g + + def _eval_terms(self, n): + """ + Returns the first `n` terms of the product formal power series. + Term by term logic is implemented here. + + Examples + ======== + + >>> from sympy import fps, sin, exp, convolution + >>> from sympy.abc import x + >>> f1 = fps(sin(x)) + >>> f2 = fps(exp(x)) + >>> fprod = f1.product(f2, x) + + >>> fprod._eval_terms(4) + x3/3 + x2 + x + + See Also + ======== + + sympy.series.formal.FormalPowerSeries.product + + """ + coeff1, coeff2 = self.coeff1, self.coeff2 + + aks = convolution(coeff1[:n], coeff2[:n]) + + terms = [] + for i in range(0, n): + terms.append(aks[i] * self.ffps.xk.coeff(i)) + + return Add(terms) + + +class FormalPowerSeriesCompose(FiniteFormalPowerSeries): + """Represents the composed formal power series of two functions. + + No computation is performed. Terms are calculated using a term by term logic, + instead of a point by point logic. + + There are two differences between a `FormalPowerSeries` object and a + `FormalPowerSeriesCompose` object. The first argument contains the outer + function and the inner function involved in the omposition. Also, the + coefficient sequence contains the generic sequence which is to be multiplied + by a custom `bell_seq` finite sequence. The finite terms will then be added up to + get the final terms. + + See Also + ======== + + sympy.series.formal.FormalPowerSeries + sympy.series.formal.FiniteFormalPowerSeries + + """ + + @property + def function(self): + """Function for the composed formal power series.""" + f, g, x = self.f, self.g, self.ffps.x + return f.subs(x, g) + + def _eval_terms(self, n): + """ + Returns the first `n` terms of the composed formal power series. + Term by term logic is implemented here. + + The coefficient sequence of the `FormalPowerSeriesCompose` object is the generic sequence. + It is multiplied by `bell_seq` to get a sequence, whose terms are added up to get + the final terms for the polynomial. + + Examples + ======== + + >>> from sympy import fps, sin, exp, bell + >>> from sympy.abc import x + >>> f1 = fps(exp(x)) + >>> f2 = fps(sin(x)) + >>> fcomp = f1.compose(f2, x) + + >>> fcomp._eval_terms(6) + -x5/15 - x4/8 + x2/2 + x + 1 + + >>> fcomp._eval_terms(8) + x7/90 - x6/240 - x5/15 - x4/8 + x2/2 + x + 1 + + See Also + ======== + + sympy.series.formal.FormalPowerSeries.compose + sympy.series.formal.FormalPowerSeries.coeff_bell + + """ + f, g = self.f, self.g + + ffps, gfps = self.ffps, self.gfps + terms = [ffps.zero_coeff()] + + for i in range(1, n): + bell_seq = gfps.coeff_bell(i) + seq = (ffps.bell_coeff_seq bell_seq) + terms.append(Add((seq[:i])) / ffps.fact_seq[i-1] ffps.xk.coeff(i)) + + return Add(terms) + + +class FormalPowerSeriesInverse(FiniteFormalPowerSeries): + """Represents the Inverse of a formal power series. + + No computation is performed. Terms are calculated using a term by term logic, + instead of a point by point logic. + + There is a single difference between a `FormalPowerSeries` object and a + `FormalPowerSeriesInverse` object. The coefficient sequence contains the + generic sequence which is to be multiplied by a custom `bell_seq` finite sequence. + The finite terms will then be added up to get the final terms. + + See Also + ======== + + sympy.series.formal.FormalPowerSeries + sympy.series.formal.FiniteFormalPowerSeries + + """ + def __init__(self, args): + ffps = self.ffps + k = ffps.xk.variables[0] + + inv = ffps.zero_coeff() + inv_seq = sequence(inv ** (-(k + 1)), (k, 1, oo)) + self.aux_seq = ffps.sign_seq * ffps.fact_seq * inv_seq + + @property + def function(self): + """Function for the inverse of a formal power series.""" + f = self.f + return 1 / f + + @property + def g(self): + raise ValueError("Only one function is considered while performing" + "inverse of a formal power series.") + + @property + def gfps(self): + raise ValueError("Only one function is considered while performing" + "inverse of a formal power series.") + + def _eval_terms(self, n): + """ + Returns the first `n` terms of the composed formal power series. + Term by term logic is implemented here. + + The coefficient sequence of the `FormalPowerSeriesInverse` object is the generic sequence. + It is multiplied by `bell_seq` to get a sequence, whose terms are added up to get + the final terms for the polynomial. + + Examples + ======== + + >>> from sympy import fps, exp, cos, bell + >>> from sympy.abc import x + >>> f1 = fps(exp(x)) + >>> f2 = fps(cos(x)) + >>> finv1, finv2 = f1.inverse(), f2.inverse() + + >>> finv1._eval_terms(6) + -x5/120 + x4/24 - x3/6 + x2/2 - x + 1 + + >>> finv2._eval_terms(8) + 61x6/720 + 5x4/24 + x2/2 + 1 + + See Also + ======== + + sympy.series.formal.FormalPowerSeries.inverse + sympy.series.formal.FormalPowerSeries.coeff_bell + + """ + f = self.f + ffps = self.ffps + terms = [ffps.zero_coeff()] + + for i in range(1, n): + bell_seq = ffps.coeff_bell(i) + seq = (self.aux_seq * bell_seq) + terms.append(Add((seq[:i])) / ffps.fact_seq[i-1] ffps.xk.coeff(i)) + + return Add(*terms) + + def fps(f, x=None, x0=0, dir=1, hyper=True, order=4, rational=True, full=False): """Generates Formal Power Series of f.	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 131bcd80a6c8..d7f688fc649f 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -3886,11 +3886,35 @@ def test_sympy__series__formal__FormalPowerSeries(): from sympy.series.formal import fps assert _test_args(fps(log(1 + x), x)) + def test_sympy__series__formal__Coeff(): from sympy.series.formal import fps assert _test_args(fps(x2 + x + 1, x)) +@SKIP('Abstract Class') +def test_sympy__series__formal__FiniteFormalPowerSeries(): + pass + + +def test_sympy__series__formal__FormalPowerSeriesProduct(): + from sympy.series.formal import fps + f1, f2 = fps(sin(x)), fps(exp(x)) + assert _test_args(f1.product(f2, x)) + + +def test_sympy__series__formal__FormalPowerSeriesCompose(): + from sympy.series.formal import fps + f1, f2 = fps(exp(x)), fps(sin(x)) + assert _test_args(f1.compose(f2, x)) + + +def test_sympy__series__formal__FormalPowerSeriesInverse(): + from sympy.series.formal import fps + f1 = fps(exp(x)) + assert _test_args(f1.inverse(x)) + + def test_sympy__simplify__hyperexpand__Hyper_Function(): from sympy.simplify.hyperexpand import Hyper_Function assert _test_args(Hyper_Function([2], [1])) diff --git a/sympy/series/tests/test_formal.py b/sympy/series/tests/test_formal.py index 86626c1ea332..2e527352b3ab 100644 --- a/sympy/series/tests/test_formal.py +++ b/sympy/series/tests/test_formal.py @@ -3,8 +3,9 @@ airyai, acos, acosh, gamma, erf, asech, Add, Integral, Mul, integrate) from sympy.series.formal import (rational_algorithm, FormalPowerSeries, - rational_independent, simpleDE, exp_re, - hyper_re) + FormalPowerSeriesProduct, FormalPowerSeriesCompose, + FormalPowerSeriesInverse, simpleDE, + rational_independent, exp_re, hyper_re) from sympy.utilities.pytest import raises, XFAIL, slow x, y, z = symbols('x y z') @@ -508,7 +509,7 @@ def test_fps__operations(): assert fi.function == sin(x) assert fi.truncate() == x - x3/6 + x5/120 + O(x6) -def test_fps__convolution(): +def test_fps__product(): f1, f2, f3 = fps(sin(x)), fps(exp(x)), fps(cos(x)) raises(ValueError, lambda: f1.product(exp(x), x)) @@ -516,11 +517,27 @@ def test_fps__convolution(): raises(ValueError, lambda: f1.product(fps(exp(x), x0=1), x, 4)) raises(ValueError, lambda: f1.product(fps(exp(y)), x, 4)) - assert f1.product(f2, x, 3) == x + x2 + O(x3) - assert f1.product(f2, x, 4) == x + x2 + x3/3 + O(x*4) - assert f1.product(f3, x, 4) == x - 2x3/3 + O(x4) + fprod = f1.product(f2, x) + assert isinstance(fprod, FormalPowerSeriesProduct) + assert isinstance(fprod.ffps, FormalPowerSeries) + assert isinstance(fprod.gfps, FormalPowerSeries) + assert fprod.f == sin(x) + assert fprod.g == exp(x) + assert fprod.function == sin(x) * exp(x) + assert fprod._eval_terms(4) == x + x2 + x3/3 + assert fprod.truncate(4) == x + x2 + x3/3 + O(x4) + assert fprod.polynomial(4) == x + x2 + x*3/3 -def test_fps__composition(): + raises(NotImplementedError, lambda: fprod._eval_term(5)) + raises(NotImplementedError, lambda: fprod.infinite) + raises(NotImplementedError, lambda: fprod._eval_derivative(x)) + raises(NotImplementedError, lambda: fprod.integrate(x)) + + assert f1.product(f3, x)._eval_terms(4) == x - 2x*3/3 + assert f1.product(f3, x).truncate(4) == x - 2x3/3 + O(x4) + + +def test_fps__compose(): f1, f2, f3 = fps(exp(x)), fps(sin(x)), fps(cos(x)) raises(ValueError, lambda: f1.compose(sin(x), x)) @@ -531,23 +548,57 @@ def test_fps__composition(): raises(ValueError, lambda: f1.compose(f3, x)) raises(ValueError, lambda: f2.compose(f3, x)) - assert f1.compose(f2, x) == 1 + x + x2/2 - x4/8 - x5/15 + O(x6) - assert f1.compose(f2, x, n=4) == 1 + x + x2/2 + O(x4) - assert f1.compose(f2, x, n=8) == \ + fcomp = f1.compose(f2, x) + assert isinstance(fcomp, FormalPowerSeriesCompose) + assert isinstance(fcomp.ffps, FormalPowerSeries) + assert isinstance(fcomp.gfps, FormalPowerSeries) + assert fcomp.f == exp(x) + assert fcomp.g == sin(x) + assert fcomp.function == exp(sin(x)) + assert fcomp._eval_terms(6) == 1 + x + x2/2 - x4/8 - x5/15 + assert fcomp.truncate() == 1 + x + x2/2 - x4/8 - x5/15 + O(x6) + assert fcomp.truncate(5) == 1 + x + x2/2 - x4/8 + O(x5) + + raises(NotImplementedError, lambda: fcomp._eval_term(5)) + raises(NotImplementedError, lambda: fcomp.infinite) + raises(NotImplementedError, lambda: fcomp._eval_derivative(x)) + raises(NotImplementedError, lambda: fcomp.integrate(x)) + + assert f1.compose(f2, x).truncate(4) == 1 + x + x2/2 + O(x4) + assert f1.compose(f2, x).truncate(8) == \ 1 + x + x2/2 - x4/8 - x5/15 - x6/240 + x7/90 + O(x8) + assert f1.compose(f2, x).truncate(6) == \ + 1 + x + x2/2 - x4/8 - x5/15 + O(x6) + + assert f2.compose(f2, x).truncate(4) == x - x3/3 + O(x4) + assert f2.compose(f2, x).truncate(8) == x - x3/3 + x5/10 - 8x7/315 + O(x8) + assert f2.compose(f2, x).truncate(6) == x - x3/3 + x5/10 + O(x6) - assert f2.compose(f2, x, n=4) == x - x3/3 + O(x4) - assert f2.compose(f2, x, n=8) == x - x3/3 + x5/10 - 8x7/315 + O(x8) def test_fps__inverse(): f1, f2, f3 = fps(sin(x)), fps(exp(x)), fps(cos(x)) raises(ValueError, lambda: f1.inverse(x)) - raises(ValueError, lambda: f1.inverse(x, n=8)) - assert f2.inverse(x) == 1 - x + x2/2 - x3/6 + x4/24 - x5/120 + O(x6) - assert f2.inverse(x, n=8) == \ + finv = f2.inverse(x) + assert isinstance(finv, FormalPowerSeriesInverse) + assert isinstance(finv.ffps, FormalPowerSeries) + raises(ValueError, lambda: finv.gfps) + + assert finv.f == exp(x) + assert finv.function == exp(-x) + assert finv._eval_terms(5) == 1 - x + x2/2 - x3/6 + x4/24 + assert finv.truncate() == 1 - x + x2/2 - x3/6 + x4/24 - x5/120 + O(x6) + assert finv.truncate(5) == 1 - x + x2/2 - x3/6 + x4/24 + O(x5) + + raises(NotImplementedError, lambda: finv._eval_term(5)) + raises(ValueError, lambda: finv.g) + raises(NotImplementedError, lambda: finv.infinite) + raises(NotImplementedError, lambda: finv._eval_derivative(x)) + raises(NotImplementedError, lambda: finv.integrate(x)) + + assert f2.inverse(x).truncate(8) == \ 1 - x + x2/2 - x3/6 + x4/24 - x5/120 + x6/720 - x7/5040 + O(x8) - assert f3.inverse(x) == 1 + x*2/2 + 5x4/24 + O(x6) - assert f3.inverse(x, n=8) == 1 + x*2/2 + 5x*4/24 + 61x6/720 + O(x8) + assert f3.inverse(x).truncate() == 1 + x*2/2 + 5x4/24 + O(x6) + assert f3.inverse(x).truncate(8) == 1 + x*2/2 + 5x*4/24 + 61x6/720 + O(x8)		[ { "components": [ { "doc": "", "lines": [ 1055, 1056 ], "name": "FormalPowerSeries.zero_coeff", "signature": "def zero_coeff(self):", "type": "function" }, { "doc": "Base Class for Product, Compose and Inverse classes"...	[ "test_rational_algorithm", "test_rational_independent", "test_simpleDE", "test_exp_re", "test_hyper_re", "test_fps", "test_fps_shift", "test_fps__Add_expr", "test_fps__asymptotic", "test_fps__fractional", "test_fps__logarithmic_singularity", "test_fps_symbolic", "test_fps__slow", "test_fps...	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [GSoC] Introduction of FormalPowerSeries sub-classes, which is being returned by product, compose and inverse functions <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs This PR is an extension of PR #17017 and PR #17064 #### Brief description of what is fixed or changed Added `FiniteFormalPowerSeries` class, in which the coefficient sequence is a list of real numbers, computed based on the algorithm of the function calling it. Presently, `compose` and `inverse`, which are functions of `FormalPowerSeries` class, return a `FiniteFormalPowerSeries` object. ``` >>> from sympy import * >>> x = symbols('x') >>> f1, f2 = fps(exp(x)), fps(sin(x)) >>> f1.compose(f2) FiniteFormalPowerSeries(exp(sin(x)), x, 0, 1, ([1, 1/2, 0, -1/8, -1/15], SeqFormula(x_k, (_k, 0, oo)), 1)) >>> f1.compose(f2).truncate(6) 1 + x + x2/2 - x4/8 - x5/15 + O(x6) >>> f1.inverse() FiniteFormalPowerSeries(exp(-x), x, 0, 1, ([-1, 1/2, -1/6, 1/24, -1/120], SeqFormula(x_k, (_k, 0, oo)), 1)) >>> f1.inverse().truncate(6) 1 - x + x2/2 - x3/6 + x4/24 - x5/120 + O(x6) ``` #### Other comments [TODO]** Once my algo PR's get merged, this PR will then require some basic minor changes. Tests and suitable documentation will be added then itself. <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * series * Added `FiniteFormalPowerSeries` class in `sympy.series.formal` <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/series/formal.py] (definition of FormalPowerSeries.zero_coeff:) def zero_coeff(self): (definition of FiniteFormalPowerSeries:) class FiniteFormalPowerSeries(FormalPowerSeries): """Base Class for Product, Compose and Inverse classes""" (definition of FiniteFormalPowerSeries.__init__:) def __init__(self, args): (definition of FiniteFormalPowerSeries.ffps:) def ffps(self): (definition of FiniteFormalPowerSeries.gfps:) def gfps(self): (definition of FiniteFormalPowerSeries.f:) def f(self): (definition of FiniteFormalPowerSeries.g:) def g(self): (definition of FiniteFormalPowerSeries.infinite:) def infinite(self): (definition of FiniteFormalPowerSeries._eval_terms:) def _eval_terms(self, n): (definition of FiniteFormalPowerSeries._eval_term:) def _eval_term(self, pt): (definition of FiniteFormalPowerSeries.polynomial:) def polynomial(self, n): (definition of FiniteFormalPowerSeries.truncate:) def truncate(self, n=6): (definition of FiniteFormalPowerSeries._eval_derivative:) def _eval_derivative(self, x): (definition of FiniteFormalPowerSeries.integrate:) def integrate(self, x): (definition of FormalPowerSeriesProduct:) class FormalPowerSeriesProduct(FiniteFormalPowerSeries): """Represents the product of two formal power series of two functions. No computation is performed. Terms are calculated using a term by term logic, instead of a point by point logic. There are two differences between a `FormalPowerSeries` object and a `FormalPowerSeriesProduct` object. The first argument contains the two functions involved in the product. Also, the coefficient sequence contains both the coefficient sequence of the formal power series of the involved functions. See Also ======== sympy.series.formal.FormalPowerSeries sympy.series.formal.FiniteFormalPowerSeries""" (definition of FormalPowerSeriesProduct.__init__:) def __init__(self, args): (definition of FormalPowerSeriesProduct.function:) def function(self): """Function of the product of two formal power series.""" (definition of FormalPowerSeriesProduct._eval_terms:) def _eval_terms(self, n): """Returns the first `n` terms of the product formal power series. Term by term logic is implemented here. Examples ======== >>> from sympy import fps, sin, exp, convolution >>> from sympy.abc import x >>> f1 = fps(sin(x)) >>> f2 = fps(exp(x)) >>> fprod = f1.product(f2, x) >>> fprod._eval_terms(4) x3/3 + x2 + x See Also ======== sympy.series.formal.FormalPowerSeries.product""" (definition of FormalPowerSeriesCompose:) class FormalPowerSeriesCompose(FiniteFormalPowerSeries): """Represents the composed formal power series of two functions. No computation is performed. Terms are calculated using a term by term logic, instead of a point by point logic. There are two differences between a `FormalPowerSeries` object and a `FormalPowerSeriesCompose` object. The first argument contains the outer function and the inner function involved in the omposition. Also, the coefficient sequence contains the generic sequence which is to be multiplied by a custom `bell_seq` finite sequence. The finite terms will then be added up to get the final terms. See Also ======== sympy.series.formal.FormalPowerSeries sympy.series.formal.FiniteFormalPowerSeries""" (definition of FormalPowerSeriesCompose.function:) def function(self): """Function for the composed formal power series.""" (definition of FormalPowerSeriesCompose._eval_terms:) def _eval_terms(self, n): """Returns the first `n` terms of the composed formal power series. Term by term logic is implemented here. The coefficient sequence of the `FormalPowerSeriesCompose` object is the generic sequence. It is multiplied by `bell_seq` to get a sequence, whose terms are added up to get the final terms for the polynomial. Examples ======== >>> from sympy import fps, sin, exp, bell >>> from sympy.abc import x >>> f1 = fps(exp(x)) >>> f2 = fps(sin(x)) >>> fcomp = f1.compose(f2, x) >>> fcomp._eval_terms(6) -x5/15 - x4/8 + x2/2 + x + 1 >>> fcomp._eval_terms(8) x7/90 - x6/240 - x5/15 - x4/8 + x2/2 + x + 1 See Also ======== sympy.series.formal.FormalPowerSeries.compose sympy.series.formal.FormalPowerSeries.coeff_bell""" (definition of FormalPowerSeriesInverse:) class FormalPowerSeriesInverse(FiniteFormalPowerSeries): """Represents the Inverse of a formal power series. No computation is performed. Terms are calculated using a term by term logic, instead of a point by point logic. There is a single difference between a `FormalPowerSeries` object and a `FormalPowerSeriesInverse` object. The coefficient sequence contains the generic sequence which is to be multiplied by a custom `bell_seq` finite sequence. The finite terms will then be added up to get the final terms. See Also ======== sympy.series.formal.FormalPowerSeries sympy.series.formal.FiniteFormalPowerSeries""" (definition of FormalPowerSeriesInverse.__init__:) def __init__(self, args): (definition of FormalPowerSeriesInverse.function:) def function(self): """Function for the inverse of a formal power series.""" (definition of FormalPowerSeriesInverse.g:) def g(self): (definition of FormalPowerSeriesInverse.gfps:) def gfps(self): (definition of FormalPowerSeriesInverse._eval_terms:) def _eval_terms(self, n): """Returns the first `n` terms of the composed formal power series. Term by term logic is implemented here. The coefficient sequence of the `FormalPowerSeriesInverse` object is the generic sequence. It is multiplied by `bell_seq` to get a sequence, whose terms are added up to get the final terms for the polynomial. Examples ======== >>> from sympy import fps, exp, cos, bell >>> from sympy.abc import x >>> f1 = fps(exp(x)) >>> f2 = fps(cos(x)) >>> finv1, finv2 = f1.inverse(), f2.inverse() >>> finv1._eval_terms(6) -x5/120 + x4/24 - x3/6 + x2/2 - x + 1 >>> finv2._eval_terms(8) 61x*6/720 + 5x4/24 + x2/2 + 1 See Also ======== sympy.series.formal.FormalPowerSeries.inverse sympy.series.formal.FormalPowerSeries.coeff_bell""" [end of new definitions in sympy/series/formal.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
scikit-learn__scikit-learn-14197	14,197	scikit-learn/scikit-learn	0.22	91819d58275adf1bb05944b9e51ff3133cebc7f9	2019-06-26T13:21:34Z	diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 2e1c639e267b7..cf3302ad62c00 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -12,6 +12,18 @@ Version 0.21.3 Changelog --------- +:mod:`sklearn.datasets` +....................... + +- \|Fix\| :func:`datasets.fetch_california_housing`, + :func:`datasets.fetch_covtype`, + :func:`datasets.fetch_kddcup99`, :func:`datasets.fetch_olivetti_faces`, + :func:`datasets.fetch_rcv1`, and :func:`datasets.fetch_species_distributions` + try to persist the previously cache using the new ``joblib`` if the cahced + data was persisted using the deprecated ``sklearn.externals.joblib``. This + behavior is set to be deprecated and removed in v0.23. + :pr:`14197` by `Adrin Jalali`_. + :mod:`sklearn.impute` ..................... diff --git a/sklearn/datasets/base.py b/sklearn/datasets/base.py index 0b8f73c86117b..c353746c1c326 100644 --- a/sklearn/datasets/base.py +++ b/sklearn/datasets/base.py @@ -10,6 +10,7 @@ import csv import sys import shutil +import warnings from collections import namedtuple from os import environ, listdir, makedirs from os.path import dirname, exists, expanduser, isdir, join, splitext @@ -919,3 +920,31 @@ def _fetch_remote(remote, dirname=None): "file may be corrupted.".format(file_path, checksum, remote.checksum)) return file_path + + +def _refresh_cache(files, compress): + # TODO: REMOVE in v0.23 + import joblib + msg = "sklearn.externals.joblib is deprecated in 0.21" + with warnings.catch_warnings(record=True) as warns: + data = tuple([joblib.load(f) for f in files]) + + refresh_needed = any([str(x.message).startswith(msg) for x in warns]) + + other_warns = [w for w in warns if not str(w.message).startswith(msg)] + for w in other_warns: + warnings.warn(message=w.message, category=w.category) + + if refresh_needed: + try: + for value, path in zip(data, files): + joblib.dump(value, path, compress=compress) + except IOError: + message = ("This dataset will stop being loadable in scikit-learn " + "version 0.23 because it references a deprecated " + "import path. Consider removing the following files " + "and allowing it to be cached anew:\n%s" + % ("\n".join(files))) + warnings.warn(message=message, category=DeprecationWarning) + + return data[0] if len(data) == 1 else data diff --git a/sklearn/datasets/california_housing.py b/sklearn/datasets/california_housing.py index 35f0847c1de05..7d8b1aa3ede45 100644 --- a/sklearn/datasets/california_housing.py +++ b/sklearn/datasets/california_housing.py @@ -34,6 +34,7 @@ from .base import _fetch_remote from .base import _pkl_filepath from .base import RemoteFileMetadata +from .base import _refresh_cache from ..utils import Bunch # The original data can be found at: @@ -129,7 +130,9 @@ def fetch_california_housing(data_home=None, download_if_missing=True, remove(archive_path) else: - cal_housing = joblib.load(filepath) + cal_housing = _refresh_cache([filepath], 6) + # TODO: Revert to the following line in v0.23 + # cal_housing = joblib.load(filepath) feature_names = ["MedInc", "HouseAge", "AveRooms", "AveBedrms", "Population", "AveOccup", "Latitude", "Longitude"] diff --git a/sklearn/datasets/covtype.py b/sklearn/datasets/covtype.py index 9d995810bee3f..4108b1d79f84b 100644 --- a/sklearn/datasets/covtype.py +++ b/sklearn/datasets/covtype.py @@ -25,6 +25,7 @@ from .base import get_data_home from .base import _fetch_remote from .base import RemoteFileMetadata +from .base import _refresh_cache from ..utils import Bunch from .base import _pkl_filepath from ..utils import check_random_state @@ -125,8 +126,10 @@ def fetch_covtype(data_home=None, download_if_missing=True, try: X, y except NameError: - X = joblib.load(samples_path) - y = joblib.load(targets_path) + X, y = _refresh_cache([samples_path, targets_path], 9) + # TODO: Revert to the following two lines in v0.23 + # X = joblib.load(samples_path) + # y = joblib.load(targets_path) if shuffle: ind = np.arange(X.shape[0]) diff --git a/sklearn/datasets/kddcup99.py b/sklearn/datasets/kddcup99.py index 837a489e7212c..f50f49f85ab6f 100644 --- a/sklearn/datasets/kddcup99.py +++ b/sklearn/datasets/kddcup99.py @@ -20,6 +20,7 @@ from .base import _fetch_remote from .base import get_data_home from .base import RemoteFileMetadata +from .base import _refresh_cache from ..utils import Bunch from ..utils import check_random_state from ..utils import shuffle as shuffle_method @@ -292,8 +293,10 @@ def _fetch_brute_kddcup99(data_home=None, try: X, y except NameError: - X = joblib.load(samples_path) - y = joblib.load(targets_path) + X, y = _refresh_cache([samples_path, targets_path], 0) + # TODO: Revert to the following two lines in v0.23 + # X = joblib.load(samples_path) + # y = joblib.load(targets_path) return Bunch(data=X, target=y) diff --git a/sklearn/datasets/olivetti_faces.py b/sklearn/datasets/olivetti_faces.py index a52f90414e104..24eeb7927abcf 100644 --- a/sklearn/datasets/olivetti_faces.py +++ b/sklearn/datasets/olivetti_faces.py @@ -24,6 +24,7 @@ from .base import _fetch_remote from .base import RemoteFileMetadata from .base import _pkl_filepath +from .base import _refresh_cache from ..utils import check_random_state, Bunch # The original data can be found at: @@ -107,7 +108,9 @@ def fetch_olivetti_faces(data_home=None, shuffle=False, random_state=0, joblib.dump(faces, filepath, compress=6) del mfile else: - faces = joblib.load(filepath) + faces = _refresh_cache([filepath], 6) + # TODO: Revert to the following line in v0.23 + # faces = joblib.load(filepath) # We want floating point data, but float32 is enough (there is only # one byte of precision in the original uint8s anyway) diff --git a/sklearn/datasets/rcv1.py b/sklearn/datasets/rcv1.py index c95cf1d1be75a..c000acf13e249 100644 --- a/sklearn/datasets/rcv1.py +++ b/sklearn/datasets/rcv1.py @@ -22,6 +22,7 @@ from .base import _pkl_filepath from .base import _fetch_remote from .base import RemoteFileMetadata +from .base import _refresh_cache from .svmlight_format import load_svmlight_files from ..utils import shuffle as shuffle_ from ..utils import Bunch @@ -189,8 +190,10 @@ def fetch_rcv1(data_home=None, subset='all', download_if_missing=True, f.close() remove(f.name) else: - X = joblib.load(samples_path) - sample_id = joblib.load(sample_id_path) + X, sample_id = _refresh_cache([samples_path, sample_id_path], 9) + # TODO: Revert to the following two lines in v0.23 + # X = joblib.load(samples_path) + # sample_id = joblib.load(sample_id_path) # load target (y), categories, and sample_id_bis if download_if_missing and (not exists(sample_topics_path) or @@ -243,8 +246,10 @@ def fetch_rcv1(data_home=None, subset='all', download_if_missing=True, joblib.dump(y, sample_topics_path, compress=9) joblib.dump(categories, topics_path, compress=9) else: - y = joblib.load(sample_topics_path) - categories = joblib.load(topics_path) + y, categories = _refresh_cache([sample_topics_path, topics_path], 9) + # TODO: Revert to the following two lines in v0.23 + # y = joblib.load(sample_topics_path) + # categories = joblib.load(topics_path) if subset == 'all': pass diff --git a/sklearn/datasets/species_distributions.py b/sklearn/datasets/species_distributions.py index f9a04f92b8486..82ae22129ab9b 100644 --- a/sklearn/datasets/species_distributions.py +++ b/sklearn/datasets/species_distributions.py @@ -51,6 +51,7 @@ from .base import RemoteFileMetadata from ..utils import Bunch from .base import _pkl_filepath +from .base import _refresh_cache # The original data can be found at: # https://biodiversityinformatics.amnh.org/open_source/maxent/samples.zip @@ -259,6 +260,8 @@ def fetch_species_distributions(data_home=None, **extra_params) joblib.dump(bunch, archive_path, compress=9) else: - bunch = joblib.load(archive_path) + bunch = _refresh_cache([archive_path], 9) + # TODO: Revert to the following line in v0.23 + # bunch = joblib.load(archive_path) return bunch	diff --git a/sklearn/datasets/tests/test_base.py b/sklearn/datasets/tests/test_base.py index 1b58115d337e7..5e0af0318729f 100644 --- a/sklearn/datasets/tests/test_base.py +++ b/sklearn/datasets/tests/test_base.py @@ -8,6 +8,7 @@ from functools import partial import pytest +import joblib import numpy as np from sklearn.datasets import get_data_home @@ -23,6 +24,7 @@ from sklearn.datasets import load_boston from sklearn.datasets import load_wine from sklearn.datasets.base import Bunch +from sklearn.datasets.base import _refresh_cache from sklearn.datasets.tests.test_common import check_return_X_y from sklearn.externals._pilutil import pillow_installed @@ -276,3 +278,55 @@ def test_bunch_dir(): # check that dir (important for autocomplete) shows attributes data = load_iris() assert "data" in dir(data) + + +def test_refresh_cache(monkeypatch): + # uses pytests monkeypatch fixture + # https://docs.pytest.org/en/latest/monkeypatch.html + + def _load_warn(args, kwargs): + # raise the warning from "externals.joblib.__init__.py" + # this is raised when a file persisted by the old joblib is loaded now + msg = ("sklearn.externals.joblib is deprecated in 0.21 and will be " + "removed in 0.23. Please import this functionality directly " + "from joblib, which can be installed with: pip install joblib. " + "If this warning is raised when loading pickled models, you " + "may need to re-serialize those models with scikit-learn " + "0.21+.") + warnings.warn(msg, DeprecationWarning) + return 0 + + def _load_warn_unrelated(args, *kwargs): + warnings.warn("unrelated warning", DeprecationWarning) + return 0 + + def _dump_safe(args, *kwargs): + pass + + def _dump_raise(args, **kwargs): + # this happens if the file is read-only and joblib.dump fails to write + # on it. + raise IOError() + + # test if the dataset spesific warning is raised if load raises the joblib + # warning, and dump fails to dump with new joblib + monkeypatch.setattr(joblib, "load", _load_warn) + monkeypatch.setattr(joblib, "dump", _dump_raise) + msg = "This dataset will stop being loadable in scikit-learn" + with pytest.warns(DeprecationWarning, match=msg): + _refresh_cache('test', 0) + + # make sure no warning is raised if load raises the warning, but dump + # manages to dump the new data + monkeypatch.setattr(joblib, "load", _load_warn) + monkeypatch.setattr(joblib, "dump", _dump_safe) + with pytest.warns(None) as warns: + _refresh_cache('test', 0) + assert len(warns) == 0 + + # test if an unrelated warning is still passed through and not suppressed + # by _refresh_cache + monkeypatch.setattr(joblib, "load", _load_warn_unrelated) + monkeypatch.setattr(joblib, "dump", _dump_safe) + with pytest.warns(DeprecationWarning, match="unrelated warning"): + _refresh_cache('test', 0)	diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 2e1c639e267b7..cf3302ad62c00 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -12,6 +12,18 @@ Version 0.21.3 Changelog --------- +:mod:`sklearn.datasets` +....................... + +- \|Fix\| :func:`datasets.fetch_california_housing`, + :func:`datasets.fetch_covtype`, + :func:`datasets.fetch_kddcup99`, :func:`datasets.fetch_olivetti_faces`, + :func:`datasets.fetch_rcv1`, and :func:`datasets.fetch_species_distributions` + try to persist the previously cache using the new ``joblib`` if the cahced + data was persisted using the deprecated ``sklearn.externals.joblib``. This + behavior is set to be deprecated and removed in v0.23. + :pr:`14197` by `Adrin Jalali`_. + :mod:`sklearn.impute` .....................	[ { "components": [ { "doc": "", "lines": [ 925, 950 ], "name": "_refresh_cache", "signature": "def _refresh_cache(files, compress):", "type": "function" } ], "file": "sklearn/datasets/base.py" } ]	[ "sklearn/datasets/tests/test_base.py::test_data_home", "sklearn/datasets/tests/test_base.py::test_default_empty_load_files", "sklearn/datasets/tests/test_base.py::test_default_load_files", "sklearn/datasets/tests/test_base.py::test_load_files_w_categories_desc_and_encoding", "sklearn/datasets/tests/test_bas...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> FIX introduce a refresh_cache param to `fetch_...` functions. This kinda fixes #14177. This does not change the warning message. But it introduces a `refresh_cache` parameter to the `fetch_...` functions that download and persist the data using `joblib`. The proposal is to add this parameter, with some variation after reviews: ``` + refresh_cache : str or bool, optional (default='joblib') + - ``True``: remove the previously downloaded data, and fetche it again. + - ``'joblib'``: only re-fetch the data if the previously downloaded + data has been persisted using the previously vendored `joblib`. + - ``False``: do not re-fetch the data. + + From version 0.23, ``'joblib'`` as an input value will be ignored and + assumed ``False``. + + .. versionadded:: 0.21.3 ``` I've changed only one of the dataset files, will fix the others once we agree on a solution. @glemaitre @jnothman ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/datasets/base.py] (definition of _refresh_cache:) def _refresh_cache(files, compress): [end of new definitions in sklearn/datasets/base.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Better warning message with deprecation of sklearn.externals._joblib When loading the olivetti dataset, I got the deprecation warning: ```python "sklearn.externals.joblib is deprecated in 0.21 and will be removed " "in 0.23. Please import this functionality directly from joblib, " "which can be installed with: pip install joblib. If this warning is " "raised when loading pickled models, you may need to re-serialize " "those models with scikit-learn 0.21+." ``` It is due that the dataset was downloaded and pickled with an old scikit-learn. I have 2 suggestions: 1. "you may need to re-serialize those models with scikit-learn 0.21+" does not seem enough. We should mention that the models should be serialized with sklearn 0.21+ and joblib directly (externals.joblib is still existing). 2. It might be interesting to detect the case of the dataset. It does not have anything to do with the models and the user might wonder what is going on. If we detect the warning after calling `fetch_***` we could first remove the pickle and re-pickle using joblib which will avoid raising the deprecation warning after. ---------- Another point which we could improve is to tell the user where those data are located. I don't think most people know where to go and delete the files. We are just mentioned the following: ``` Specify another download and cache folder for the datasets. By default all scikit-learn data is stored in ‘~/scikit_learn_data’ subfolders. ``` I might not make it easy for Windows users to know what mean `~/`. Yes, but that's hidden in the docstring of the parameter, and most users would just call the function with the default value, then get the warning message, and not know how to follow up with it. Oh I see. Yes you are right. I would be okay to detect this case and re-cache over a deprecation period... (but we have to also allow for the cache not being writable, I think.) It could even go into 0.21.3 > I would be okay to detect this case and re-cache over a deprecation period... (but we have to also allow for the cache not being writable, I think.) You mean to automatically re-cache now, until a certain version? or the other way around? I think re-cache now until a certain version?? Sounds good to me, I'll get on it :) Thanks @adrinjalali -------------------- </issues>	c96e0958da46ebef482a4084cdda3285d5f5ad23
scikit-learn__scikit-learn-14180	14,180	scikit-learn/scikit-learn	0.23	b9403f62ac65e7e6575168ef74b43fb012010599	2019-06-25T02:18:38Z	diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 3d9924638b69b..2489eaf55bac7 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -1569,6 +1569,7 @@ Plotting utils.deprecated utils.estimator_checks.check_estimator utils.estimator_checks.parametrize_with_checks + utils.estimator_html_repr utils.extmath.safe_sparse_dot utils.extmath.randomized_range_finder utils.extmath.randomized_svd diff --git a/doc/modules/compose.rst b/doc/modules/compose.rst index cd29b14b1f081..e7dac0dadc630 100644 --- a/doc/modules/compose.rst +++ b/doc/modules/compose.rst @@ -528,6 +528,31 @@ above example would be:: ('countvectorizer', CountVectorizer(), 'title')]) +.. _visualizing_composite_estimators: + +Visualizing Composite Estimators +================================ + +Estimators can be displayed with a HTML representation when shown in a +jupyter notebook. This can be useful to diagnose or visualize a Pipeline with +many estimators. This visualization is activated by setting the +`display` option in :func:`sklearn.set_config`:: + + >>> from sklearn import set_config + >>> set_config(display='diagram') # doctest: +SKIP + >>> # diplays HTML representation in a jupyter context + >>> column_trans # doctest: +SKIP + +An example of the HTML output can be seen in the +HTML representation of Pipeline section of +:ref:`sphx_glr_auto_examples_compose_plot_column_transformer_mixed_types.py`. +As an alternative, the HTML can be written to a file using +:func:`~sklearn.utils.estimator_html_repr`:: + + >>> from sklearn.utils import estimator_html_repr + >>> with open('my_estimator.html', 'w') as f: # doctest: +SKIP + ... f.write(estimator_html_repr(clf)) + .. topic:: Examples: * :ref:`sphx_glr_auto_examples_compose_plot_column_transformer.py` diff --git a/doc/whats_new/v0.23.rst b/doc/whats_new/v0.23.rst index 0e149ed03a9fa..1ac63ca473faf 100644 --- a/doc/whats_new/v0.23.rst +++ b/doc/whats_new/v0.23.rst @@ -567,6 +567,9 @@ Changelog :mod:`sklearn.utils` .................... +- \|Feature\| Adds :func:`utils.estimator_html_repr` for returning a + HTML representation of an estimator. :pr:`14180` by `Thomas Fan`_. + - \|Enhancement\| improve error message in :func:`utils.validation.column_or_1d`. :pr:`15926` by :user:`Loïc Estève <lesteve>`. @@ -605,6 +608,11 @@ Changelog Miscellaneous ............. +- \|MajorFeature\| Adds a HTML representation of estimators to be shown in + a jupyter notebook or lab. This visualization is acitivated by setting the + `display` option in :func:`sklearn.set_config`. :pr:`14180` by + `Thomas Fan`_. + - \|Enhancement\| ``scikit-learn`` now works with ``mypy`` without errors. :pr:`16726` by `Roman Yurchak`_. diff --git a/examples/compose/plot_column_transformer_mixed_types.py b/examples/compose/plot_column_transformer_mixed_types.py index 1c79c4bb1d607..24fc4d69e35d0 100644 --- a/examples/compose/plot_column_transformer_mixed_types.py +++ b/examples/compose/plot_column_transformer_mixed_types.py @@ -87,6 +87,15 @@ clf.fit(X_train, y_train) print("model score: %.3f" % clf.score(X_test, y_test)) +############################################################################## +# HTML representation of ``Pipeline`` +############################################################################### +# When the ``Pipeline`` is printed out in a jupyter notebook an HTML +# representation of the estimator is displayed as follows: +from sklearn import set_config +set_config(display='diagram') +clf + ############################################################################### # Use ``ColumnTransformer`` by selecting column by data types ############################################################################### diff --git a/sklearn/_config.py b/sklearn/_config.py index 44eaae1d59012..f183203e13228 100644 --- a/sklearn/_config.py +++ b/sklearn/_config.py @@ -7,6 +7,7 @@ 'assume_finite': bool(os.environ.get('SKLEARN_ASSUME_FINITE', False)), 'working_memory': int(os.environ.get('SKLEARN_WORKING_MEMORY', 1024)), 'print_changed_only': True, + 'display': 'text', } @@ -27,7 +28,7 @@ def get_config(): def set_config(assume_finite=None, working_memory=None, - print_changed_only=None): + print_changed_only=None, display=None): """Set global scikit-learn configuration .. versionadded:: 0.19 @@ -59,6 +60,13 @@ def set_config(assume_finite=None, working_memory=None, .. versionadded:: 0.21 + display : {'text', 'diagram'}, optional + If 'diagram', estimators will be displayed as text in a jupyter lab + of notebook context. If 'text', estimators will be displayed as + text. Default is 'text'. + + .. versionadded:: 0.23 + See Also -------- config_context: Context manager for global scikit-learn configuration @@ -70,6 +78,8 @@ def set_config(assume_finite=None, working_memory=None, _global_config['working_memory'] = working_memory if print_changed_only is not None: _global_config['print_changed_only'] = print_changed_only + if display is not None: + _global_config['display'] = display @contextmanager @@ -100,6 +110,13 @@ def config_context(new_config): .. versionchanged:: 0.23 Default changed from False to True. + display : {'text', 'diagram'}, optional + If 'diagram', estimators will be displayed as text in a jupyter lab + of notebook context. If 'text', estimators will be displayed as + text. Default is 'text'. + + .. versionadded:: 0.23 + Notes ----- All settings, not just those presently modified, will be returned to diff --git a/sklearn/base.py b/sklearn/base.py index bf5ee370aa8f1..666574b491594 100644 --- a/sklearn/base.py +++ b/sklearn/base.py @@ -17,9 +17,11 @@ import numpy as np from . import __version__ +from ._config import get_config from .utils import _IS_32BIT from .utils.validation import check_X_y from .utils.validation import check_array +from .utils._estimator_html_repr import estimator_html_repr from .utils.validation import _deprecate_positional_args _DEFAULT_TAGS = { @@ -435,6 +437,17 @@ def _validate_data(self, X, y=None, reset=True, return out + def _repr_html_(self): + """HTML representation of estimator""" + return estimator_html_repr(self) + + def _repr_mimebundle_(self, kwargs): + """Mime bundle used by jupyter kernels to display estimator""" + output = {"text/plain": repr(self)} + if get_config()["display"] == 'diagram': + output["text/html"] = estimator_html_repr(self) + return output + class ClassifierMixin: """Mixin class for all classifiers in scikit-learn.""" diff --git a/sklearn/compose/_column_transformer.py b/sklearn/compose/_column_transformer.py index 2ef8876b0c4e7..f148633021a97 100644 --- a/sklearn/compose/_column_transformer.py +++ b/sklearn/compose/_column_transformer.py @@ -15,6 +15,7 @@ from joblib import Parallel, delayed from ..base import clone, TransformerMixin +from ..utils._estimator_html_repr import _VisualBlock from ..pipeline import _fit_transform_one, _transform_one, _name_estimators from ..preprocessing import FunctionTransformer from ..utils import Bunch @@ -637,6 +638,11 @@ def _hstack(self, Xs): Xs = [f.toarray() if sparse.issparse(f) else f for f in Xs] return np.hstack(Xs) + def _sk_visual_block_(self): + names, transformers, name_details = zip(self.transformers) + return _VisualBlock('parallel', transformers, + names=names, name_details=name_details) + def _check_X(X): """Use check_array only on lists and other non-array-likes / sparse""" diff --git a/sklearn/ensemble/_stacking.py b/sklearn/ensemble/_stacking.py index a75e9236f1612..73aa55c0575a7 100644 --- a/sklearn/ensemble/_stacking.py +++ b/sklearn/ensemble/_stacking.py @@ -13,6 +13,7 @@ from ..base import clone from ..base import ClassifierMixin, RegressorMixin, TransformerMixin from ..base import is_classifier, is_regressor +from ..utils._estimator_html_repr import _VisualBlock from ._base import _fit_single_estimator from ._base import _BaseHeterogeneousEnsemble @@ -233,6 +234,14 @@ def predict(self, X, predict_params): self.transform(X), predict_params ) + def _sk_visual_block_(self, final_estimator): + names, estimators = zip(self.estimators) + parallel = _VisualBlock('parallel', estimators, names=names, + dash_wrapped=False) + serial = _VisualBlock('serial', (parallel, final_estimator), + dash_wrapped=False) + return _VisualBlock('serial', [serial]) + class StackingClassifier(ClassifierMixin, _BaseStacking): """Stack of estimators with a final classifier. @@ -496,6 +505,15 @@ def transform(self, X): """ return self._transform(X) + def _sk_visual_block_(self): + # If final_estimator's default changes then this should be + # updated. + if self.final_estimator is None: + final_estimator = LogisticRegression() + else: + final_estimator = self.final_estimator + return super()._sk_visual_block_(final_estimator) + class StackingRegressor(RegressorMixin, _BaseStacking): """Stack of estimators with a final regressor. @@ -665,3 +683,12 @@ def transform(self, X): Prediction outputs for each estimator. """ return self._transform(X) + + def _sk_visual_block_(self): + # If final_estimator's default changes then this should be + # updated. + if self.final_estimator is None: + final_estimator = RidgeCV() + else: + final_estimator = self.final_estimator + return super()._sk_visual_block_(final_estimator) diff --git a/sklearn/ensemble/_voting.py b/sklearn/ensemble/_voting.py index 0ac42407f5998..6a2b5736d8b4e 100644 --- a/sklearn/ensemble/_voting.py +++ b/sklearn/ensemble/_voting.py @@ -32,6 +32,7 @@ from ..utils.validation import column_or_1d from ..utils.validation import _deprecate_positional_args from ..exceptions import NotFittedError +from ..utils._estimator_html_repr import _VisualBlock class _BaseVoting(TransformerMixin, _BaseHeterogeneousEnsemble): @@ -104,6 +105,10 @@ def n_features_in_(self): return self.estimators_[0].n_features_in_ + def _sk_visual_block_(self): + names, estimators = zip(self.estimators) + return _VisualBlock('parallel', estimators, names=names) + class VotingClassifier(ClassifierMixin, _BaseVoting): """Soft Voting/Majority Rule classifier for unfitted estimators. diff --git a/sklearn/pipeline.py b/sklearn/pipeline.py index 8e2a539786557..6f02cb565e15c 100644 --- a/sklearn/pipeline.py +++ b/sklearn/pipeline.py @@ -18,6 +18,7 @@ from joblib import Parallel, delayed from .base import clone, TransformerMixin +from .utils._estimator_html_repr import _VisualBlock from .utils.metaestimators import if_delegate_has_method from .utils import Bunch, _print_elapsed_time from .utils.validation import check_memory @@ -623,6 +624,21 @@ def n_features_in_(self): # delegate to first step (which will call _check_is_fitted) return self.steps[0][1].n_features_in_ + def _sk_visual_block_(self): + _, estimators = zip(self.steps) + + def _get_name(name, est): + if est is None or est == 'passthrough': + return f'{name}: passthrough' + # Is an estimator + return f'{name}: {est.__class__.__name__}' + names = [_get_name(name, est) for name, est in self.steps] + name_details = [str(est) for est in estimators] + return _VisualBlock('serial', estimators, + names=names, + name_details=name_details, + dash_wrapped=False) + def _name_estimators(estimators): """Generate names for estimators.""" @@ -1004,6 +1020,10 @@ def n_features_in_(self): # X is passed to all transformers so we just delegate to the first one return self.transformer_list[0][1].n_features_in_ + def _sk_visual_block_(self): + names, transformers = zip(self.transformer_list) + return _VisualBlock('parallel', transformers, names=names) + def make_union(transformers, *kwargs): """ diff --git a/sklearn/utils/__init__.py b/sklearn/utils/__init__.py index afde7614070fd..f814ea11c12c1 100644 --- a/sklearn/utils/__init__.py +++ b/sklearn/utils/__init__.py @@ -25,6 +25,7 @@ from ..exceptions import DataConversionWarning from .deprecation import deprecated from .fixes import np_version +from ._estimator_html_repr import estimator_html_repr from .validation import (as_float_array, assert_all_finite, check_random_state, column_or_1d, check_array, @@ -52,7 +53,7 @@ "check_symmetric", "indices_to_mask", "deprecated", "parallel_backend", "register_parallel_backend", "resample", "shuffle", "check_matplotlib_support", "all_estimators", - "DataConversionWarning" + "DataConversionWarning", "estimator_html_repr" ] IS_PYPY = platform.python_implementation() == 'PyPy' diff --git a/sklearn/utils/_estimator_html_repr.py b/sklearn/utils/_estimator_html_repr.py new file mode 100644 index 0000000000000..9b2e45790fd2b --- /dev/null +++ b/sklearn/utils/_estimator_html_repr.py @@ -0,0 +1,311 @@ +from contextlib import closing +from contextlib import suppress +from io import StringIO +import uuid +import html + +from sklearn import config_context + + +class _VisualBlock: + """HTML Representation of Estimator + + Parameters + ---------- + kind : {'serial', 'parallel', 'single'} + kind of HTML block + + estimators : list of estimators or `_VisualBlock`s or a single estimator + If kind != 'single', then `estimators` is a list of + estimators. + If kind == 'single', then `estimators` is a single estimator. + + names : list of str + If kind != 'single', then `names` corresponds to estimators. + If kind == 'single', then `names` is a single string corresponding to + the single estimator. + + name_details : list of str, str, or None, default=None + If kind != 'single', then `name_details` corresponds to `names`. + If kind == 'single', then `name_details` is a single string + corresponding to the single estimator. + + dash_wrapped : bool, default=True + If true, wrapped HTML element will be wrapped with a dashed border. + Only active when kind != 'single'. + """ + def __init__(self, kind, estimators, , names=None, name_details=None, + dash_wrapped=True): + self.kind = kind + self.estimators = estimators + self.dash_wrapped = dash_wrapped + + if self.kind in ('parallel', 'serial'): + if names is None: + names = (None, ) * len(estimators) + if name_details is None: + name_details = (None, ) * len(estimators) + + self.names = names + self.name_details = name_details + + def _sk_visual_block_(self): + return self + + +def _write_label_html(out, name, name_details, + outer_class="sk-label-container", + inner_class="sk-label", + checked=False): + """Write labeled html with or without a dropdown with named details""" + out.write(f'<div class="{outer_class}">' + f'<div class="{inner_class} sk-toggleable">') + name = html.escape(name) + + if name_details is not None: + checked_str = 'checked' if checked else '' + est_id = uuid.uuid4() + out.write(f'<input class="sk-toggleable__control sk-hidden--visually" ' + f'id="{est_id}" type="checkbox" {checked_str}>' + f'<label class="sk-toggleable__label" for="{est_id}">' + f'{name}</label>' + f'<div class="sk-toggleable__content"><pre>{name_details}' + f'</pre></div>') + else: + out.write(f'<label>{name}</label>') + out.write('</div></div>') # outer_class inner_class + + +def _get_visual_block(estimator): + """Generate information about how to display an estimator. + """ + with suppress(AttributeError): + return estimator._sk_visual_block_() + + if isinstance(estimator, str): + return _VisualBlock('single', estimator, + names=estimator, name_details=estimator) + elif estimator is None: + return _VisualBlock('single', estimator, + names='None', name_details='None') + + # check if estimator looks like a meta estimator wraps estimators + if hasattr(estimator, 'get_params'): + estimators = [] + for key, value in estimator.get_params().items(): + # Only look at the estimators in the first layer + if '__' not in key and hasattr(value, 'get_params'): + estimators.append(value) + if len(estimators): + return _VisualBlock('parallel', estimators, names=None) + + return _VisualBlock('single', estimator, + names=estimator.__class__.__name__, + name_details=str(estimator)) + + +def _write_estimator_html(out, estimator, estimator_label, + estimator_label_details, first_call=False): + """Write estimator to html in serial, parallel, or by itself (single). + """ + if first_call: + est_block = _get_visual_block(estimator) + else: + with config_context(print_changed_only=True): + est_block = _get_visual_block(estimator) + + if est_block.kind in ('serial', 'parallel'): + dashed_wrapped = first_call or est_block.dash_wrapped + dash_cls = " sk-dashed-wrapped" if dashed_wrapped else "" + out.write(f'<div class="sk-item{dash_cls}">') + + if estimator_label: + _write_label_html(out, estimator_label, estimator_label_details) + + kind = est_block.kind + out.write(f'<div class="sk-{kind}">') + est_infos = zip(est_block.estimators, est_block.names, + est_block.name_details) + + for est, name, name_details in est_infos: + if kind == 'serial': + _write_estimator_html(out, est, name, name_details) + else: # parallel + out.write('<div class="sk-parallel-item">') + # wrap element in a serial visualblock + serial_block = _VisualBlock('serial', [est], + dash_wrapped=False) + _write_estimator_html(out, serial_block, name, name_details) + out.write('</div>') # sk-parallel-item + + out.write('</div></div>') + elif est_block.kind == 'single': + _write_label_html(out, est_block.names, est_block.name_details, + outer_class="sk-item", inner_class="sk-estimator", + checked=first_call) + + +_STYLE = """ +div.sk-top-container { + color: black; + background-color: white; +} +div.sk-toggleable { + background-color: white; +} +label.sk-toggleable__label { + cursor: pointer; + display: block; + width: 100%; + margin-bottom: 0; + padding: 0.2em 0.3em; + box-sizing: border-box; + text-align: center; +} +div.sk-toggleable__content { + max-height: 0; + max-width: 0; + overflow: hidden; + text-align: left; + background-color: #f0f8ff; +} +div.sk-toggleable__content pre { + margin: 0.2em; + color: black; + border-radius: 0.25em; + background-color: #f0f8ff; +} +input.sk-toggleable__control:checked~div.sk-toggleable__content { + max-height: 200px; + max-width: 100%; + overflow: auto; +} +div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label { + background-color: #d4ebff; +} +div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label { + background-color: #d4ebff; +} +input.sk-hidden--visually { + border: 0; + clip: rect(1px 1px 1px 1px); + clip: rect(1px, 1px, 1px, 1px); + height: 1px; + margin: -1px; + overflow: hidden; + padding: 0; + position: absolute; + width: 1px; +} +div.sk-estimator { + font-family: monospace; + background-color: #f0f8ff; + margin: 0.25em 0.25em; + border: 1px dotted black; + border-radius: 0.25em; + box-sizing: border-box; +} +div.sk-estimator:hover { + background-color: #d4ebff; +} +div.sk-parallel-item::after { + content: ""; + width: 100%; + border-bottom: 1px solid gray; + flex-grow: 1; +} +div.sk-label:hover label.sk-toggleable__label { + background-color: #d4ebff; +} +div.sk-serial::before { + content: ""; + position: absolute; + border-left: 1px solid gray; + box-sizing: border-box; + top: 2em; + bottom: 0; + left: 50%; +} +div.sk-serial { + display: flex; + flex-direction: column; + align-items: center; + background-color: white; +} +div.sk-item { + z-index: 1; +} +div.sk-parallel { + display: flex; + align-items: stretch; + justify-content: center; + background-color: white; +} +div.sk-parallel-item { + display: flex; + flex-direction: column; + position: relative; + background-color: white; +} +div.sk-parallel-item:first-child::after { + align-self: flex-end; + width: 50%; +} +div.sk-parallel-item:last-child::after { + align-self: flex-start; + width: 50%; +} +div.sk-parallel-item:only-child::after { + width: 0; +} +div.sk-dashed-wrapped { + border: 1px dashed gray; + margin: 0.2em; + box-sizing: border-box; + padding-bottom: 0.1em; + background-color: white; + position: relative; +} +div.sk-label label { + font-family: monospace; + font-weight: bold; + background-color: white; + display: inline-block; + line-height: 1.2em; +} +div.sk-label-container { + position: relative; + z-index: 2; + text-align: center; +} +div.sk-container { + display: inline-block; + position: relative; +} +""".replace(' ', '').replace('\n', '') # noqa + + +def estimator_html_repr(estimator): + """Build a HTML representation of an estimator. + + Read more in the :ref:`User Guide <visualizing_composite_estimators>`. + + Parameters + ---------- + estimator : estimator object + The estimator to visualize. + + Returns + ------- + html: str + HTML representation of estimator. + """ + with closing(StringIO()) as out: + out.write(f'<style>{_STYLE}</style>' + f'<div class="sk-top-container"><div class="sk-container">') + _write_estimator_html(out, estimator, estimator.__class__.__name__, + str(estimator), first_call=True) + out.write('</div></div>') + + html_output = out.getvalue() + return html_output	diff --git a/sklearn/tests/test_base.py b/sklearn/tests/test_base.py index 52f2e60b4af70..e20fa440d1933 100644 --- a/sklearn/tests/test_base.py +++ b/sklearn/tests/test_base.py @@ -23,6 +23,7 @@ from sklearn.base import TransformerMixin from sklearn.utils._mocking import MockDataFrame +from sklearn import config_context import pickle @@ -511,3 +512,16 @@ def fit(self, X, y=None): params = est.get_params() assert params['param'] is None + + +def test_repr_mimebundle_(): + # Checks the display configuration flag controls the json output + tree = DecisionTreeClassifier() + output = tree._repr_mimebundle_() + assert "text/plain" in output + assert "text/html" not in output + + with config_context(display='diagram'): + output = tree._repr_mimebundle_() + assert "text/plain" in output + assert "text/html" in output diff --git a/sklearn/tests/test_config.py b/sklearn/tests/test_config.py index ae13c61838694..eec349861258c 100644 --- a/sklearn/tests/test_config.py +++ b/sklearn/tests/test_config.py @@ -4,7 +4,8 @@ def test_config_context(): assert get_config() == {'assume_finite': False, 'working_memory': 1024, - 'print_changed_only': True} + 'print_changed_only': True, + 'display': 'text'} # Not using as a context manager affects nothing config_context(assume_finite=True) @@ -12,7 +13,8 @@ def test_config_context(): with config_context(assume_finite=True): assert get_config() == {'assume_finite': True, 'working_memory': 1024, - 'print_changed_only': True} + 'print_changed_only': True, + 'display': 'text'} assert get_config()['assume_finite'] is False with config_context(assume_finite=True): @@ -37,7 +39,8 @@ def test_config_context(): assert get_config()['assume_finite'] is True assert get_config() == {'assume_finite': False, 'working_memory': 1024, - 'print_changed_only': True} + 'print_changed_only': True, + 'display': 'text'} # No positional arguments assert_raises(TypeError, config_context, True) diff --git a/sklearn/utils/tests/test_estimator_html_repr.py b/sklearn/utils/tests/test_estimator_html_repr.py new file mode 100644 index 0000000000000..47d33051bd9a7 --- /dev/null +++ b/sklearn/utils/tests/test_estimator_html_repr.py @@ -0,0 +1,267 @@ +from contextlib import closing +from io import StringIO + +import pytest + +from sklearn import config_context +from sklearn.linear_model import LogisticRegression +from sklearn.neural_network import MLPClassifier +from sklearn.impute import SimpleImputer +from sklearn.decomposition import PCA +from sklearn.decomposition import TruncatedSVD +from sklearn.pipeline import Pipeline +from sklearn.pipeline import FeatureUnion +from sklearn.compose import ColumnTransformer +from sklearn.ensemble import VotingClassifier +from sklearn.feature_selection import SelectPercentile +from sklearn.cluster import Birch +from sklearn.cluster import AgglomerativeClustering +from sklearn.preprocessing import OneHotEncoder +from sklearn.svm import LinearSVC +from sklearn.svm import LinearSVR +from sklearn.tree import DecisionTreeClassifier +from sklearn.multiclass import OneVsOneClassifier +from sklearn.ensemble import StackingClassifier +from sklearn.ensemble import StackingRegressor +from sklearn.gaussian_process import GaussianProcessRegressor +from sklearn.gaussian_process.kernels import RationalQuadratic +from sklearn.utils._estimator_html_repr import _write_label_html +from sklearn.utils._estimator_html_repr import _get_visual_block +from sklearn.utils._estimator_html_repr import estimator_html_repr + + +@pytest.mark.parametrize("checked", [True, False]) +def test_write_label_html(checked): + # Test checking logic and labeling + name = "LogisticRegression" + tool_tip = "hello-world" + + with closing(StringIO()) as out: + _write_label_html(out, name, tool_tip, checked=checked) + html_label = out.getvalue() + assert 'LogisticRegression</label>' in html_label + assert html_label.startswith('<div class="sk-label-container">') + assert '<pre>hello-world</pre>' in html_label + if checked: + assert 'checked>' in html_label + + +@pytest.mark.parametrize('est', ['passthrough', 'drop', None]) +def test_get_visual_block_single_str_none(est): + # Test estimators that are represnted by strings + est_html_info = _get_visual_block(est) + assert est_html_info.kind == 'single' + assert est_html_info.estimators == est + assert est_html_info.names == str(est) + assert est_html_info.name_details == str(est) + + +def test_get_visual_block_single_estimator(): + est = LogisticRegression(C=10.0) + est_html_info = _get_visual_block(est) + assert est_html_info.kind == 'single' + assert est_html_info.estimators == est + assert est_html_info.names == est.__class__.__name__ + assert est_html_info.name_details == str(est) + + +def test_get_visual_block_pipeline(): + pipe = Pipeline([ + ('imputer', SimpleImputer()), + ('do_nothing', 'passthrough'), + ('do_nothing_more', None), + ('classifier', LogisticRegression()) + ]) + est_html_info = _get_visual_block(pipe) + assert est_html_info.kind == 'serial' + assert est_html_info.estimators == tuple(step[1] for step in pipe.steps) + assert est_html_info.names == ['imputer: SimpleImputer', + 'do_nothing: passthrough', + 'do_nothing_more: passthrough', + 'classifier: LogisticRegression'] + assert est_html_info.name_details == [str(est) for _, est in pipe.steps] + + +def test_get_visual_block_feature_union(): + f_union = FeatureUnion([ + ('pca', PCA()), ('svd', TruncatedSVD()) + ]) + est_html_info = _get_visual_block(f_union) + assert est_html_info.kind == 'parallel' + assert est_html_info.names == ('pca', 'svd') + assert est_html_info.estimators == tuple( + trans[1] for trans in f_union.transformer_list) + assert est_html_info.name_details == (None, None) + + +def test_get_visual_block_voting(): + clf = VotingClassifier([ + ('log_reg', LogisticRegression()), + ('mlp', MLPClassifier()) + ]) + est_html_info = _get_visual_block(clf) + assert est_html_info.kind == 'parallel' + assert est_html_info.estimators == tuple(trans[1] + for trans in clf.estimators) + assert est_html_info.names == ('log_reg', 'mlp') + assert est_html_info.name_details == (None, None) + + +def test_get_visual_block_column_transformer(): + ct = ColumnTransformer([ + ('pca', PCA(), ['num1', 'num2']), + ('svd', TruncatedSVD, [0, 3]) + ]) + est_html_info = _get_visual_block(ct) + assert est_html_info.kind == 'parallel' + assert est_html_info.estimators == tuple( + trans[1] for trans in ct.transformers) + assert est_html_info.names == ('pca', 'svd') + assert est_html_info.name_details == (['num1', 'num2'], [0, 3]) + + +def test_estimator_html_repr_pipeline(): + num_trans = Pipeline(steps=[ + ('pass', 'passthrough'), + ('imputer', SimpleImputer(strategy='median')) + ]) + + cat_trans = Pipeline(steps=[ + ('imputer', SimpleImputer(strategy='constant', + missing_values='empty')), + ('one-hot', OneHotEncoder(drop='first')) + ]) + + preprocess = ColumnTransformer([ + ('num', num_trans, ['a', 'b', 'c', 'd', 'e']), + ('cat', cat_trans, [0, 1, 2, 3]) + ]) + + feat_u = FeatureUnion([ + ('pca', PCA(n_components=1)), + ('tsvd', Pipeline([('first', TruncatedSVD(n_components=3)), + ('select', SelectPercentile())])) + ]) + + clf = VotingClassifier([ + ('lr', LogisticRegression(solver='lbfgs', random_state=1)), + ('mlp', MLPClassifier(alpha=0.001)) + ]) + + pipe = Pipeline([ + ('preprocessor', preprocess), ('feat_u', feat_u), ('classifier', clf) + ]) + html_output = estimator_html_repr(pipe) + + # top level estimators show estimator with changes + assert str(pipe) in html_output + for _, est in pipe.steps: + assert (f"<div class=\"sk-toggleable__content\">" + f"<pre>{str(est)}") in html_output + + # low level estimators do not show changes + with config_context(print_changed_only=True): + assert str(num_trans['pass']) in html_output + assert 'passthrough</label>' in html_output + assert str(num_trans['imputer']) in html_output + + for _, _, cols in preprocess.transformers: + assert f"<pre>{cols}</pre>" in html_output + + # feature union + for name, _ in feat_u.transformer_list: + assert f"<label>{name}</label>" in html_output + + pca = feat_u.transformer_list[0][1] + assert f"<pre>{str(pca)}</pre>" in html_output + + tsvd = feat_u.transformer_list[1][1] + first = tsvd['first'] + select = tsvd['select'] + assert f"<pre>{str(first)}</pre>" in html_output + assert f"<pre>{str(select)}</pre>" in html_output + + # voting classifer + for name, est in clf.estimators: + assert f"<label>{name}</label>" in html_output + assert f"<pre>{str(est)}</pre>" in html_output + + +@pytest.mark.parametrize("final_estimator", [None, LinearSVC()]) +def test_stacking_classsifer(final_estimator): + estimators = [('mlp', MLPClassifier(alpha=0.001)), + ('tree', DecisionTreeClassifier())] + clf = StackingClassifier( + estimators=estimators, final_estimator=final_estimator) + + html_output = estimator_html_repr(clf) + + assert str(clf) in html_output + # If final_estimator's default changes from LogisticRegression + # this should be updated + if final_estimator is None: + assert "LogisticRegression(" in html_output + else: + assert final_estimator.__class__.__name__ in html_output + + +@pytest.mark.parametrize("final_estimator", [None, LinearSVR()]) +def test_stacking_regressor(final_estimator): + reg = StackingRegressor( + estimators=[('svr', LinearSVR())], final_estimator=final_estimator) + html_output = estimator_html_repr(reg) + + assert str(reg.estimators[0][0]) in html_output + assert "LinearSVR</label>" in html_output + if final_estimator is None: + assert "RidgeCV</label>" in html_output + else: + assert final_estimator.__class__.__name__ in html_output + + +def test_birch_duck_typing_meta(): + # Test duck typing meta estimators with Birch + birch = Birch(n_clusters=AgglomerativeClustering(n_clusters=3)) + html_output = estimator_html_repr(birch) + + # inner estimators do not show changes + with config_context(print_changed_only=True): + assert f"<pre>{str(birch.n_clusters)}" in html_output + assert "AgglomerativeClustering</label>" in html_output + + # outer estimator contains all changes + assert f"<pre>{str(birch)}" in html_output + + +def test_ovo_classifier_duck_typing_meta(): + # Test duck typing metaestimators with OVO + ovo = OneVsOneClassifier(LinearSVC(penalty='l1')) + html_output = estimator_html_repr(ovo) + + # inner estimators do not show changes + with config_context(print_changed_only=True): + assert f"<pre>{str(ovo.estimator)}" in html_output + assert "LinearSVC</label>" in html_output + + # outter estimator + assert f"<pre>{str(ovo)}" in html_output + + +def test_duck_typing_nested_estimator(): + # Test duck typing metaestimators with GP + kernel = RationalQuadratic(length_scale=1.0, alpha=0.1) + gp = GaussianProcessRegressor(kernel=kernel) + html_output = estimator_html_repr(gp) + + assert f"<pre>{str(kernel)}" in html_output + assert f"<pre>{str(gp)}" in html_output + + +@pytest.mark.parametrize('print_changed_only', [True, False]) +def test_one_estimator_print_change_only(print_changed_only): + pca = PCA(n_components=10) + + with config_context(print_changed_only=print_changed_only): + pca_repr = str(pca) + html_output = estimator_html_repr(pca) + assert pca_repr in html_output	diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 3d9924638b69b..2489eaf55bac7 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -1569,6 +1569,7 @@ Plotting utils.deprecated utils.estimator_checks.check_estimator utils.estimator_checks.parametrize_with_checks + utils.estimator_html_repr utils.extmath.safe_sparse_dot utils.extmath.randomized_range_finder utils.extmath.randomized_svd diff --git a/doc/modules/compose.rst b/doc/modules/compose.rst index cd29b14b1f081..e7dac0dadc630 100644 --- a/doc/modules/compose.rst +++ b/doc/modules/compose.rst @@ -528,6 +528,31 @@ above example would be:: ('countvectorizer', CountVectorizer(), 'title')]) +.. _visualizing_composite_estimators: + +Visualizing Composite Estimators +================================ + +Estimators can be displayed with a HTML representation when shown in a +jupyter notebook. This can be useful to diagnose or visualize a Pipeline with +many estimators. This visualization is activated by setting the +`display` option in :func:`sklearn.set_config`:: + + >>> from sklearn import set_config + >>> set_config(display='diagram') # doctest: +SKIP + >>> # diplays HTML representation in a jupyter context + >>> column_trans # doctest: +SKIP + +An example of the HTML output can be seen in the +HTML representation of Pipeline section of +:ref:`sphx_glr_auto_examples_compose_plot_column_transformer_mixed_types.py`. +As an alternative, the HTML can be written to a file using +:func:`~sklearn.utils.estimator_html_repr`:: + + >>> from sklearn.utils import estimator_html_repr + >>> with open('my_estimator.html', 'w') as f: # doctest: +SKIP + ... f.write(estimator_html_repr(clf)) + .. topic:: Examples: * :ref:`sphx_glr_auto_examples_compose_plot_column_transformer.py` diff --git a/doc/whats_new/v0.23.rst b/doc/whats_new/v0.23.rst index 0e149ed03a9fa..1ac63ca473faf 100644 --- a/doc/whats_new/v0.23.rst +++ b/doc/whats_new/v0.23.rst @@ -567,6 +567,9 @@ Changelog :mod:`sklearn.utils` .................... +- \|Feature\| Adds :func:`utils.estimator_html_repr` for returning a + HTML representation of an estimator. :pr:`14180` by `Thomas Fan`_. + - \|Enhancement\| improve error message in :func:`utils.validation.column_or_1d`. :pr:`15926` by :user:`Loïc Estève <lesteve>`. @@ -605,6 +608,11 @@ Changelog Miscellaneous ............. +- \|MajorFeature\| Adds a HTML representation of estimators to be shown in + a jupyter notebook or lab. This visualization is acitivated by setting the + `display` option in :func:`sklearn.set_config`. :pr:`14180` by + `Thomas Fan`_. + - \|Enhancement\| ``scikit-learn`` now works with ``mypy`` without errors. :pr:`16726` by `Roman Yurchak`_.	[ { "components": [ { "doc": "HTML representation of estimator", "lines": [ 440, 442 ], "name": "BaseEstimator._repr_html_", "signature": "def _repr_html_(self):", "type": "function" }, { "doc": "Mime bundle used by jupy...	[ "sklearn/tests/test_base.py::test_clone", "sklearn/tests/test_base.py::test_clone_2", "sklearn/tests/test_base.py::test_clone_buggy", "sklearn/tests/test_base.py::test_clone_empty_array", "sklearn/tests/test_base.py::test_clone_nan", "sklearn/tests/test_base.py::test_clone_sparse_matrices", "sklearn/tes...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> ENH Adds HTML visualizations for estimators #### Reference Issues/PRs Closes https://github.com/scikit-learn/scikit-learn/issues/14061 #### What does this implement/fix? Explain your changes. You can demo the visualization here: https://thomasjpfan.github.io/sklearn_viz_html/index.html This PR implements a HTML visualization for estimators with a focus on displaying it in a Jupyter notebook or lab. This implementation is in pure HTML and CSS (no javascript or external dependencies): ![Screen Shot 2019-06-28 at 4 16 20 PM](https://user-images.githubusercontent.com/5402633/60368922-19f88a00-99c0-11e9-9397-06acf766390d.png) 1. We can hover over elements to see an estimators parameters (`print_changed_only=True` is the default for `export_html`): <img width="549" alt="Screen Shot 2019-06-24 at 10 11 36 PM" src="https://user-images.githubusercontent.com/5402633/60064008-14075e00-96cd-11e9-9fc1-c1b4c4de6484.png"> 2. All the labels in bold can be hovered over to get more information. 3. `_type_of_html_estimator` returns how to layout metaestimators, (`ColumnTransformer` and `FeatureUnion` is "parallel", while `Pipeline` is "serial") If there are any other metaestimators to add, we just need to add it to `_type_of_html_estimator`) 4. There is a hidden div `sk-final-spacer` as a hack to provide enough space for the information displayed while hovering over elements. <details> <summary>Code to Create HTML (In jupyterlab or a notebook)</summary> ```py from sklearn.compose import ColumnTransformer from sklearn.pipeline import Pipeline from sklearn.impute import SimpleImputer from sklearn.preprocessing import StandardScaler, OneHotEncoder from sklearn.linear_model import LogisticRegression from sklearn.decomposition import PCA, TruncatedSVD from sklearn.linear_model import LogisticRegression from sklearn.naive_bayes import GaussianNB from sklearn.ensemble import RandomForestClassifier, VotingClassifier from sklearn.pipeline import FeatureUnion from sklearn.feature_selection import SelectPercentile from sklearn.inspection import display_estimator # We create the preprocessing pipelines for both numeric and categorical data. numeric_features = ['age', 'fare'] numeric_transformer = Pipeline(steps=[ ('imputer', SimpleImputer(strategy='median'))]) feat_u2 = FeatureUnion([("pca", PCA(n_components=1)), ("svd", Pipeline([('tsvd1', TruncatedSVD(n_components=2)), ('select', SelectPercentile())]))]) numeric_transformer2 = Pipeline(steps=[ ('imputer', SimpleImputer(strategy='most_frequent')), ('scaler', StandardScaler(with_std=False)), ('feats', feat_u2) ]) categorical_features = ['embarked', 'sex', 'pclass'] categorical_transformer = Pipeline(steps=[ ('imputer', SimpleImputer(strategy='constant', missing_values="missing")), ('onehot', OneHotEncoder(handle_unknown='ignore', drop='first'))]) preprocessor = ColumnTransformer( transformers=[ ('num1', numeric_transformer, numeric_features), ('num2', numeric_transformer2, numeric_features), ('cat', categorical_transformer, categorical_features)]) feat_u = FeatureUnion([("pca", PCA(n_components=1, whiten=True, svd_solver='full')), ("svd", TruncatedSVD(n_components=2, n_iter=10))]) clf1 = LogisticRegression(solver='lbfgs', multi_class='multinomial', random_state=1, max_iter=200) clf2 = RandomForestClassifier(n_estimators=50, random_state=1, max_depth=8, warm_start=True, n_jobs=3, oob_score=True) clf3 = GaussianNB() eclf1 = VotingClassifier(estimators=[ ('lr', clf1), ('rf', clf2), ('gnb', clf3)], voting='hard') clf = Pipeline(steps=[('preprocessor', preprocessor), ('feat_u', feat_u), ('classifier', eclf1)]) display_estimator(clf) ``` </details> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/base.py] (definition of BaseEstimator._repr_html_:) def _repr_html_(self): """HTML representation of estimator""" (definition of BaseEstimator._repr_mimebundle_:) def _repr_mimebundle_(self, *kwargs): """Mime bundle used by jupyter kernels to display estimator""" [end of new definitions in sklearn/base.py] [start of new definitions in sklearn/compose/_column_transformer.py] (definition of ColumnTransformer._sk_visual_block_:) def _sk_visual_block_(self): [end of new definitions in sklearn/compose/_column_transformer.py] [start of new definitions in sklearn/ensemble/_stacking.py] (definition of _BaseStacking._sk_visual_block_:) def _sk_visual_block_(self, final_estimator): (definition of StackingClassifier._sk_visual_block_:) def _sk_visual_block_(self): (definition of StackingRegressor._sk_visual_block_:) def _sk_visual_block_(self): [end of new definitions in sklearn/ensemble/_stacking.py] [start of new definitions in sklearn/ensemble/_voting.py] (definition of _BaseVoting._sk_visual_block_:) def _sk_visual_block_(self): [end of new definitions in sklearn/ensemble/_voting.py] [start of new definitions in sklearn/pipeline.py] (definition of Pipeline._sk_visual_block_:) def _sk_visual_block_(self): (definition of Pipeline._sk_visual_block_._get_name:) def _get_name(name, est): (definition of FeatureUnion._sk_visual_block_:) def _sk_visual_block_(self): [end of new definitions in sklearn/pipeline.py] [start of new definitions in sklearn/utils/_estimator_html_repr.py] (definition of _VisualBlock:) class _VisualBlock: """HTML Representation of Estimator Parameters ---------- kind : {'serial', 'parallel', 'single'} kind of HTML block estimators : list of estimators or `_VisualBlock`s or a single estimator If kind != 'single', then `estimators` is a list of estimators. If kind == 'single', then `estimators` is a single estimator. names : list of str If kind != 'single', then `names` corresponds to estimators. If kind == 'single', then `names` is a single string corresponding to the single estimator. name_details : list of str, str, or None, default=None If kind != 'single', then `name_details` corresponds to `names`. If kind == 'single', then `name_details` is a single string corresponding to the single estimator. dash_wrapped : bool, default=True If true, wrapped HTML element will be wrapped with a dashed border. Only active when kind != 'single'.""" (definition of _VisualBlock.__init__:) def __init__(self, kind, estimators, , names=None, name_details=None, dash_wrapped=True): (definition of _VisualBlock._sk_visual_block_:) def _sk_visual_block_(self): (definition of _write_label_html:) def _write_label_html(out, name, name_details, outer_class="sk-label-container", inner_class="sk-label", checked=False): """Write labeled html with or without a dropdown with named details""" (definition of _get_visual_block:) def _get_visual_block(estimator): """Generate information about how to display an estimator. """ (definition of _write_estimator_html:) def _write_estimator_html(out, estimator, estimator_label, estimator_label_details, first_call=False): """Write estimator to html in serial, parallel, or by itself (single). """ (definition of estimator_html_repr:) def estimator_html_repr(estimator): """Build a HTML representation of an estimator. Read more in the :ref:`User Guide <visualizing_composite_estimators>`. Parameters ---------- estimator : estimator object The estimator to visualize. Returns ------- html: str HTML representation of estimator.""" [end of new definitions in sklearn/utils/_estimator_html_repr.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		4bb4856ee8f3198740d53dd28b0b1d2767b90795
sympy__sympy-17078	17,078	sympy/sympy	1.5	f50c2d86a7be2003b26211971c3e335d59325348	2019-06-23T19:42:02Z	diff --git a/sympy/functions/__init__.py b/sympy/functions/__init__.py index bcacdc3c08f6..b43bfcd5914f 100644 --- a/sympy/functions/__init__.py +++ b/sympy/functions/__init__.py @@ -35,7 +35,7 @@ from sympy.functions.special.delta_functions import DiracDelta, Heaviside from sympy.functions.special.bsplines import bspline_basis, bspline_basis_set, interpolating_spline from sympy.functions.special.bessel import (besselj, bessely, besseli, besselk, - hankel1, hankel2, jn, yn, jn_zeros, hn1, hn2, airyai, airybi, airyaiprime, airybiprime) + hankel1, hankel2, jn, yn, jn_zeros, hn1, hn2, airyai, airybi, airyaiprime, airybiprime, marcumq) from sympy.functions.special.hyper import hyper, meijerg, appellf1 from sympy.functions.special.polynomials import (legendre, assoc_legendre, hermite, chebyshevt, chebyshevu, chebyshevu_root, chebyshevt_root, diff --git a/sympy/functions/special/bessel.py b/sympy/functions/special/bessel.py index c883cb8c8c43..6d043316ce30 100644 --- a/sympy/functions/special/bessel.py +++ b/sympy/functions/special/bessel.py @@ -1660,3 +1660,96 @@ def _eval_expand_func(self, hints): pf = (dm * z*(nm)) / (d * zn)m newarg = c * d*m z*(nm) return S.Half * (sqrt(3)(pf - S.One)airyaiprime(newarg) + (pf + S.One)airybiprime(newarg)) + + +class marcumq(Function): + r""" + The Marcum Q-function + + It is defined by the meromorphic continuation of + + .. math:: + Q_m(a, b) = a^{- m + 1} \int_{b}^{\infty} x^{m} e^{- \frac{a^{2}}{2} - \frac{x^{2}}{2}} I_{m - 1}\left(a x\right)\, dx + + Examples + ======== + + >>> from sympy import marcumq + >>> from sympy.abc import m, a, b, x + >>> marcumq(m, a, b) + marcumq(m, a, b) + + Special values: + + >>> marcumq(m, 0, b) + uppergamma(m, b2/2)/gamma(m) + >>> marcumq(0, 0, 0) + 0 + >>> marcumq(0, a, 0) + 1 - exp(-a2/2) + >>> marcumq(1, a, a) + 1/2 + exp(-a2)besseli(0, a2)/2 + >>> marcumq(2, a, a) + 1/2 + exp(-a2)besseli(0, a2)/2 + exp(-a2)besseli(1, a*2) + + Differentiation with respect to a and b is supported: + + >>> from sympy import diff + >>> diff(marcumq(m, a, b), a) + a(-marcumq(m, a, b) + marcumq(m + 1, a, b)) + >>> diff(marcumq(m, a, b), b) + -a*(1 - m)b*mexp(-a2/2 - b2/2)besseli(m - 1, ab) + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Marcum_Q-function + .. [2] http://mathworld.wolfram.com/MarcumQ-Function.html + """ + + @classmethod + def eval(cls, m, a, b): + from sympy import exp, uppergamma + if a == 0: + if m == 0 and b == 0: + return S.Zero + return uppergamma(m, b2 / 2) / gamma(m) + + if m == 0 and b == 0: + return 1 - 1 / exp(a2 / 2) + + if a == b: + if m == 1: + return (1 + exp(-a*2) besseli(0, a*2)) / 2 + if m == 2: + return S.Half + S.Half exp(-a*2) besseli(0, a2) + exp(-a2) * besseli(1, a*2) + + def fdiff(self, argindex=2): + from sympy import exp + m, a, b = self.args + if argindex == 2: + return a (-marcumq(m, a, b) + marcumq(1+m, a, b)) + elif argindex == 3: + return (-bm / a(m-1)) * exp(-(a2 + b2)/2) * besseli(m-1, ab) + else: + raise ArgumentIndexError(self, argindex) + + def _eval_rewrite_as_Integral(self, m, a, b, kwargs): + from sympy import Integral, exp, Dummy, oo + x = kwargs.get('x', Dummy('x')) + return a * (1 - m) * \ + Integral(x*m exp(-(x2 + a2)/2) * besseli(m-1, ax), [x, b, oo]) + + def _eval_rewrite_as_Sum(self, m, a, b, kwargs): + from sympy import Sum, exp, Dummy, oo + k = kwargs.get('k', Dummy('k')) + return exp(-(a2 + b2) / 2) Sum((a/b)*k besseli(k, ab), [k, 1-m, oo]) + + def _eval_rewrite_as_besseli(self, m, a, b, kwargs): + if a == b: + from sympy import exp + if m == 1: + return (1 + exp(-a2) besseli(0, a2)) / 2 + if m.is_Integer and m >= 2: + s = sum([besseli(i, a2) for i in range(1, m)]) + return S.Half + exp(-a*2) besseli(0, a2) / 2 + exp(-a2) * s	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index a8f7f03755c2..879023ea2c38 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -2064,6 +2064,11 @@ def test_sympy__functions__special__bessel__airybiprime(): assert _test_args(airybiprime(2)) +def test_sympy__functions__special__bessel__marcumq(): + from sympy.functions.special.bessel import marcumq + assert _test_args(marcumq(x, y, z)) + + def test_sympy__functions__special__elliptic_integrals__elliptic_k(): from sympy.functions.special.elliptic_integrals import elliptic_k as K assert _test_args(K(x)) diff --git a/sympy/functions/special/tests/test_bessel.py b/sympy/functions/special/tests/test_bessel.py index e9e25f0f59b3..80d4d6332dc0 100644 --- a/sympy/functions/special/tests/test_bessel.py +++ b/sympy/functions/special/tests/test_bessel.py @@ -3,10 +3,10 @@ from sympy import (jn, yn, symbols, Symbol, sin, cos, pi, S, jn_zeros, besselj, bessely, besseli, besselk, hankel1, hankel2, hn1, hn2, expand_func, sqrt, sinh, cosh, diff, series, gamma, hyper, - Abs, I, O, oo, conjugate) + Abs, I, O, oo, conjugate, uppergamma, exp, Integral, Sum) from sympy.functions.special.bessel import fn from sympy.functions.special.bessel import (airyai, airybi, - airyaiprime, airybiprime) + airyaiprime, airybiprime, marcumq) from sympy.utilities.randtest import (random_complex_number as randcplx, verify_numerically as tn, test_derivative_numerically as td, @@ -557,3 +557,44 @@ def test_airybiprime(): assert expand_func(airybiprime(2(3z5)(S(1)/3))) == ( sqrt(3)(z(S(5)/3)/(z5)(S(1)/3) - 1)airyaiprime(23(S(1)/3)z(S(5)/3))/2 + (z(S(5)/3)/(z5)(S(1)/3) + 1)airybiprime(23*(S(1)/3)z(S(5)/3))/2) + + +def test_marcumq(): + m = Symbol('m') + a = Symbol('a') + b = Symbol('b') + + assert marcumq(0, 0, 0) == 0 + assert marcumq(m, 0, b) == uppergamma(m, b2/2)/gamma(m) + assert marcumq(2, 0, 5) == 27exp(-S(25)/2)/2 + assert marcumq(0, a, 0) == 1 - exp(-a2/2) + assert marcumq(0, pi, 0) == 1 - exp(-pi2/2) + assert marcumq(1, a, a) == S.Half + exp(-a2)besseli(0, a2)/2 + assert marcumq(2, a, a) == S.Half + exp(-a2)besseli(0, a2)/2 + exp(-a2)besseli(1, a*2) + + assert diff(marcumq(1, a, 3), a) == a(-marcumq(1, a, 3) + marcumq(2, a, 3)) + assert diff(marcumq(2, 3, b), b) == -b*2exp(-b*2/2 - S(9)/2)besseli(1, 3b)/3 + + x = Symbol('x') + assert marcumq(2, 3, 4).rewrite(Integral, x=x) == \ + Integral(x2exp(-x*2/2 - S(9)/2)besseli(1, 3x), (x, 4, oo))/3 + assert eq([marcumq(5, -2, 3).rewrite(Integral).evalf(10)], + [0.7905769565]) + + k = Symbol('k') + assert marcumq(-3, -5, -7).rewrite(Sum, k=k) == \ + exp(-37)Sum((S(5)/7)*kbesseli(k, 35), (k, 4, oo)) + assert eq([marcumq(1, 3, 1).rewrite(Sum).evalf(10)], + [0.9891705502]) + + assert marcumq(1, a, a, evaluate=False).rewrite(besseli) == S.Half + exp(-a*2)besseli(0, a2)/2 + assert marcumq(2, a, a, evaluate=False).rewrite(besseli) == S.Half + exp(-a2)besseli(0, a2)/2 + \ + exp(-a2)besseli(1, a2) + assert marcumq(3, a, a).rewrite(besseli) == (besseli(1, a2) + besseli(2, a*2))exp(-a2) + \ + S.Half + exp(-a2)besseli(0, a2)/2 + assert marcumq(5, 8, 8).rewrite(besseli) == exp(-64)besseli(0, 64)/2 + \ + (besseli(4, 64) + besseli(3, 64) + besseli(2, 64) + besseli(1, 64))*exp(-64) + S.Half + assert marcumq(m, a, a).rewrite(besseli) == marcumq(m, a, a) + + x = Symbol('x', integer=True) + assert marcumq(x, a, a).rewrite(besseli) == marcumq(x, a, a)		[ { "components": [ { "doc": "The Marcum Q-function\n\nIt is defined by the meromorphic continuation of\n\n.. math::\n Q_m(a, b) = a^{- m + 1} \\int_{b}^{\\infty} x^{m} e^{- \\frac{a^{2}}{2} - \\frac{x^{2}}{2}} I_{m - 1}\\left(a x\\right)\\, dx\n\nExamples\n========\n\n>>> from sympy import marcu...	[ "test_sympy__functions__special__bessel__marcumq", "test_bessel_rand", "test_bessel_twoinputs", "test_diff", "test_rewrite", "test_expand", "test_fn", "test_jn", "test_yn", "test_sympify_yn", "test_jn_zeros", "test_bessel_eval", "test_bessel_nan", "test_conjugate", "test_branching", "t...	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add Marcum Q-function Closes #17073. #### Brief description of what is fixed or changed Added [Marcum Q-function](http://mathworld.wolfram.com/MarcumQ-Function.html) to `bessel.py`, with differentiation and some special values. Also implemented rewriting as a sum of Bessel functions. #### Release Notes <!-- BEGIN RELEASE NOTES --> * functions * Added Marcum Q-function. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/functions/special/bessel.py] (definition of marcumq:) class marcumq(Function): """The Marcum Q-function It is defined by the meromorphic continuation of .. math:: Q_m(a, b) = a^{- m + 1} \int_{b}^{\infty} x^{m} e^{- \frac{a^{2}}{2} - \frac{x^{2}}{2}} I_{m - 1}\left(a x\right)\, dx Examples ======== >>> from sympy import marcumq >>> from sympy.abc import m, a, b, x >>> marcumq(m, a, b) marcumq(m, a, b) Special values: >>> marcumq(m, 0, b) uppergamma(m, b2/2)/gamma(m) >>> marcumq(0, 0, 0) 0 >>> marcumq(0, a, 0) 1 - exp(-a2/2) >>> marcumq(1, a, a) 1/2 + exp(-a*2)besseli(0, a2)/2 >>> marcumq(2, a, a) 1/2 + exp(-a2)besseli(0, a2)/2 + exp(-a2)besseli(1, a*2) Differentiation with respect to a and b is supported: >>> from sympy import diff >>> diff(marcumq(m, a, b), a) a(-marcumq(m, a, b) + marcumq(m + 1, a, b)) >>> diff(marcumq(m, a, b), b) -a*(1 - m)b*mexp(-a2/2 - b2/2)besseli(m - 1, ab) References ========== .. [1] https://en.wikipedia.org/wiki/Marcum_Q-function .. [2] http://mathworld.wolfram.com/MarcumQ-Function.html""" (definition of marcumq.eval:) def eval(cls, m, a, b): (definition of marcumq.fdiff:) def fdiff(self, argindex=2): (definition of marcumq._eval_rewrite_as_Integral:) def _eval_rewrite_as_Integral(self, m, a, b, kwargs): (definition of marcumq._eval_rewrite_as_Sum:) def _eval_rewrite_as_Sum(self, m, a, b, kwargs): (definition of marcumq._eval_rewrite_as_besseli:) def _eval_rewrite_as_besseli(self, m, a, b, **kwargs): [end of new definitions in sympy/functions/special/bessel.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Implement Marcum Q-function The Marcum Q-function is used as a cumulative distribution function (more precisely, as a survivor function) for noncentral chi, noncentral chi-squared and Rice distributions. This function also arises in performance analysis of partially coherent, differentially coherent, and noncoherent communications. References: [1] [wiki](https://en.wikipedia.org/wiki/Marcum_Q-function) [2] [wolfram](http://mathworld.wolfram.com/MarcumQ-Function.html) <img width="454" alt="MarcumQ" src="https://user-images.githubusercontent.com/34616054/59972653-a7973c80-95b0-11e9-9494-0b0976e68adf.png"> ---------- Where would it be located- in `bessel.py`? Yes, I too think that it should be located in `bessel.py` since it uses `besseli` function. -------------------- </issues>	c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-17077	17,077	sympy/sympy	1.5	e6a5b6cb700f9aee594d80bea058ca19a95551cc	2019-06-23T18:49:41Z	diff --git a/sympy/stats/__init__.py b/sympy/stats/__init__.py index 5364fce2185d..635094919db9 100644 --- a/sympy/stats/__init__.py +++ b/sympy/stats/__init__.py @@ -42,7 +42,7 @@ from . import rv_interface from .rv_interface import ( cdf, characteristic_function, covariance, density, dependent, E, given, independent, P, pspace, - random_symbols, sample, sample_iter, skewness, kurtosis, std, variance, where, + random_symbols, sample, sample_iter, skewness, kurtosis, std, variance, where, factorial_moment, correlation, moment, cmoment, smoment, sampling_density, moment_generating_function, entropy, H, quantile ) diff --git a/sympy/stats/rv_interface.py b/sympy/stats/rv_interface.py index 18050b356e71..c87dd79e75e4 100644 --- a/sympy/stats/rv_interface.py +++ b/sympy/stats/rv_interface.py @@ -1,13 +1,13 @@ from __future__ import print_function, division -from sympy import sqrt, Symbol, log, exp +from sympy import sqrt, Symbol, log, exp, FallingFactorial from .rv import (probability, expectation, density, where, given, pspace, cdf, characteristic_function, sample, sample_iter, random_symbols, independent, dependent, sampling_density, moment_generating_function, quantile) __all__ = ['P', 'E', 'H', 'density', 'where', 'given', 'sample', 'cdf', 'characteristic_function', 'pspace', 'sample_iter', 'variance', 'std', 'skewness', 'kurtosis', 'covariance', - 'dependent', 'independent', 'random_symbols', 'correlation', + 'dependent', 'independent', 'random_symbols', 'correlation', 'factorial_moment', 'moment', 'cmoment', 'sampling_density', 'moment_generating_function', 'quantile'] @@ -292,12 +292,50 @@ def kurtosis(X, condition=None, kwargs): References ========== + .. [1] https://en.wikipedia.org/wiki/Kurtosis .. [2] http://mathworld.wolfram.com/Kurtosis.html """ return smoment(X, 4, condition=condition, kwargs) +def factorial_moment(X, n, condition=None, *kwargs): + """ + The factorial moment is a mathematical quantity defined as the expectation + or average of the falling factorial of a random variable. + + factorial_moment(X, n) = E(X(X - 1)(X - 2)...(X - n + 1)) + + Parameters + ========== + + n: A natural number, n-th factorial moment. + + condition : Expr containing RandomSymbols + A conditional expression. + + Examples + ======== + + >>> from sympy.stats import factorial_moment, Poisson, Binomial + >>> from sympy import Symbol, S + >>> lamda = Symbol('lamda') + >>> X = Poisson('X', lamda) + >>> factorial_moment(X, 2) + lamda2 + >>> Y = Binomial('Y', 2, S.Half) + >>> factorial_moment(Y, 2) + 1/2 + >>> factorial_moment(Y, 2, Y > 1) # find factorial moment for Y > 1 + 2 + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Factorial_moment + .. [2] http://mathworld.wolfram.com/FactorialMoment.html + """ + return expectation(FallingFactorial(X, n), condition=condition, *kwargs) P = probability	diff --git a/sympy/stats/tests/test_rv.py b/sympy/stats/tests/test_rv.py index 417fe79b5c6b..2f4a53fe3464 100644 --- a/sympy/stats/tests/test_rv.py +++ b/sympy/stats/tests/test_rv.py @@ -1,11 +1,11 @@ -from sympy import (S, Symbol, Interval, +from sympy import (S, Symbol, symbols, Interval, FallingFactorial, Eq, cos, And, Tuple, integrate, oo, sin, Sum, Basic, DiracDelta, log, pi) from sympy.core.compatibility import range from sympy.core.numbers import comp from sympy.stats import (Die, Normal, Exponential, FiniteRV, P, E, H, variance, - density, given, independent, dependent, where, pspace, - random_symbols, sample, Geometric) + density, given, independent, dependent, where, pspace, factorial_moment, + random_symbols, sample, Geometric, Binomial, Poisson, Hypergeometric) from sympy.stats.frv_types import BernoulliDistribution from sympy.stats.rv import (IndependentProductPSpace, rs_swap, Density, NamedArgsMixin, RandomSymbol, PSpace) @@ -152,6 +152,24 @@ def test_given(): assert X == A == B +def test_factorial_moment(): + X = Poisson('X', 2) + Y = Binomial('Y', 2, S.Half) + Z = Hypergeometric('Z', 4, 2, 2) + assert factorial_moment(X, 2) == 4 + assert factorial_moment(Y, 2) == S(1)/2 + assert factorial_moment(Z, 2) == S(1)/3 + + x, y, z, l = symbols('x y z l') + Y = Binomial('Y', 2, y) + Z = Hypergeometric('Z', 10, 2, 3) + assert factorial_moment(Y, l) == y*2FallingFactorial( + 2, l) + 2y(1 - y)FallingFactorial(1, l) + (1 - y)2\ + FallingFactorial(0, l) + assert factorial_moment(Z, l) == 7FallingFactorial(0, l)/\ + 15 + 7FallingFactorial(1, l)/15 + FallingFactorial(2, l)/15 + + def test_dependence(): X, Y = Die('X'), Die('Y') assert independent(X, 2*Y)		[ { "components": [ { "doc": "The factorial moment is a mathematical quantity defined as the expectation\nor average of the falling factorial of a random variable.\n\nfactorial_moment(X, n) = E(X(X - 1)(X - 2)...(X - n + 1))\n\nParameters\n==========\n\nn: A natural number, n-th factorial moment...	[ "test_where", "test_random_symbols", "test_pspace", "test_rs_swap", "test_RandomSymbol", "test_RandomSymbol_diff", "test_random_symbol_no_pspace", "test_overlap", "test_IndependentProductPSpace", "test_E", "test_H", "test_Sample", "test_given", "test_factorial_moment", "test_dependence",...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added Factorial Moment <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> Added factorial moment under `sympy/stats/rv_interface.py` #### Brief description of what is fixed or changed #### Other comments Ping @sidhantnagpal #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - stats - Added factorial moment function under `sympy/stats/rv_interface.py` <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/rv_interface.py] (definition of factorial_moment:) def factorial_moment(X, n, condition=None, *kwargs): """The factorial moment is a mathematical quantity defined as the expectation or average of the falling factorial of a random variable. factorial_moment(X, n) = E(X(X - 1)(X - 2)...(X - n + 1)) Parameters ========== n: A natural number, n-th factorial moment. condition : Expr containing RandomSymbols A conditional expression. Examples ======== >>> from sympy.stats import factorial_moment, Poisson, Binomial >>> from sympy import Symbol, S >>> lamda = Symbol('lamda') >>> X = Poisson('X', lamda) >>> factorial_moment(X, 2) lamda*2 >>> Y = Binomial('Y', 2, S.Half) >>> factorial_moment(Y, 2) 1/2 >>> factorial_moment(Y, 2, Y > 1) # find factorial moment for Y > 1 2 References ========== .. [1] https://en.wikipedia.org/wiki/Factorial_moment .. [2] http://mathworld.wolfram.com/FactorialMoment.html""" [end of new definitions in sympy/stats/rv_interface.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-17075	17,075	sympy/sympy	1.5	3729e1ba5a2afcfc3ceee7b98b07d5b57303f919	2019-06-23T12:43:58Z	diff --git a/sympy/printing/mathml.py b/sympy/printing/mathml.py index e5012efe74d8..3e48f1365f9e 100644 --- a/sympy/printing/mathml.py +++ b/sympy/printing/mathml.py @@ -741,6 +741,53 @@ def _print_NegativeInfinity(self, e): mrow.appendChild(x) return mrow + def _print_HBar(self, e): + x = self.dom.createElement('mi') + x.appendChild(self.dom.createTextNode('ℏ')) + return x + + def _print_EulerGamma(self, e): + x = self.dom.createElement('mi') + x.appendChild(self.dom.createTextNode('γ')) + return x + + def _print_TribonacciConstant(self, e): + x = self.dom.createElement('mi') + x.appendChild(self.dom.createTextNode('TribonacciConstant')) + return x + + def _print_Dagger(self, e): + msup = self.dom.createElement('msup') + msup.appendChild(self._print(e.args[0])) + msup.appendChild(self.dom.createTextNode('†')) + return msup + + def _print_Contains(self, e): + mrow = self.dom.createElement('mrow') + mrow.appendChild(self._print(e.args[0])) + mo = self.dom.createElement('mo') + mo.appendChild(self.dom.createTextNode('∈')) + mrow.appendChild(mo) + mrow.appendChild(self._print(e.args[1])) + return mrow + + def _print_HilbertSpace(self, e): + x = self.dom.createElement('mi') + x.appendChild(self.dom.createTextNode('ℋ')) + return x + + def _print_ComplexSpace(self, e): + msup = self.dom.createElement('msup') + msup.appendChild(self.dom.createTextNode('𝒞')) + msup.appendChild(self._print(e.args[0])) + return msup + + def _print_FockSpace(self, e): + x = self.dom.createElement('mi') + x.appendChild(self.dom.createTextNode('ℱ')) + return x + + def _print_Integral(self, expr): intsymbols = {1: "∫", 2: "∬", 3: "∭"}	diff --git a/sympy/printing/tests/test_mathml.py b/sympy/printing/tests/test_mathml.py index 4aed2e33394d..7e57d6a157be 100644 --- a/sympy/printing/tests/test_mathml.py +++ b/sympy/printing/tests/test_mathml.py @@ -4,7 +4,7 @@ S, MatrixSymbol, Function, Derivative, log, true, false, Range, Min, Max, \ Lambda, IndexedBase, symbols, zoo, elliptic_f, elliptic_e, elliptic_pi, Ei, \ expint, jacobi, gegenbauer, chebyshevt, chebyshevu, legendre, assoc_legendre, \ - laguerre, assoc_laguerre, hermite + laguerre, assoc_laguerre, hermite, TribonacciConstant, EulerGamma, Contains from sympy import elliptic_k, totient, reduced_totient, primenu, primeomega, \ fresnelc, fresnels, Heaviside @@ -22,6 +22,7 @@ from sympy.functions.special.zeta_functions import polylog, lerchphi, zeta, dirichlet_eta from sympy.logic.boolalg import And, Or, Implies, Equivalent, Xor, Not from sympy.matrices.expressions.determinant import Determinant +from sympy.physics.quantum import ComplexSpace, HilbertSpace, FockSpace, hbar, Dagger from sympy.printing.mathml import mathml, MathMLContentPrinter, \ MathMLPresentationPrinter, MathMLPrinter from sympy.sets.sets import FiniteSet, Union, Intersection, Complement, \ @@ -1141,6 +1142,27 @@ def test_print_UniversalSet(): assert mpp.doprint(S.UniversalSet) == '<mo>𝕌</mo>' +def test_print_spaces(): + assert mpp.doprint(HilbertSpace()) == '<mi>ℋ</mi>' + assert mpp.doprint(ComplexSpace(2)) == '<msup>𝒞<mn>2</mn></msup>' + assert mpp.doprint(FockSpace()) == '<mi>ℱ</mi>' + + +def test_print_constants(): + assert mpp.doprint(hbar) == '<mi>ℏ</mi>' + assert mpp.doprint(TribonacciConstant) == '<mi>TribonacciConstant</mi>' + assert mpp.doprint(EulerGamma) == '<mi>γ</mi>' + + +def test_print_Contains(): + assert mpp.doprint(Contains(x, S.Naturals)) == \ + '<mrow><mi>x</mi><mo>∈</mo><mi mathvariant="normal">ℕ</mi></mrow>' + + +def test_print_Dagger(): + assert mpp.doprint(Dagger(x)) == '<msup><mi>x</mi>†</msup>' + + def test_print_SetOp(): f1 = FiniteSet(x, 1, 3) f2 = FiniteSet(y, 2, 4)		[ { "components": [ { "doc": "", "lines": [ 744, 747 ], "name": "MathMLPresentationPrinter._print_HBar", "signature": "def _print_HBar(self, e):", "type": "function" }, { "doc": "", "lines": [ 749, ...	[ "test_print_spaces", "test_print_constants", "test_print_Contains", "test_print_Dagger" ]	[ "test_mathml_printer", "test_content_printmethod", "test_content_mathml_core", "test_content_mathml_functions", "test_content_mathml_limits", "test_content_mathml_integrals", "test_content_mathml_matrices", "test_content_mathml_sums", "test_content_mathml_tuples", "test_content_mathml_add", "tes...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added some MathML presentation printing methods <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> Related to #16036 #### Brief description of what is fixed or changed Added printing of some constants, spaces, and functions. Before: <img width="578" alt="beforeconstants" src="https://user-images.githubusercontent.com/8114497/59976459-28603380-95c5-11e9-877c-61cf5cd40c7a.PNG"> After: <img width="563" alt="afterconstants" src="https://user-images.githubusercontent.com/8114497/59976461-2f874180-95c5-11e9-813f-0b24d05d1c16.PNG"> #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * printing * Added MathML presentation printing of some constants and spaces. * Added MathML presentation printing of `Contains` and `Dagger`. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/printing/mathml.py] (definition of MathMLPresentationPrinter._print_HBar:) def _print_HBar(self, e): (definition of MathMLPresentationPrinter._print_EulerGamma:) def _print_EulerGamma(self, e): (definition of MathMLPresentationPrinter._print_TribonacciConstant:) def _print_TribonacciConstant(self, e): (definition of MathMLPresentationPrinter._print_Dagger:) def _print_Dagger(self, e): (definition of MathMLPresentationPrinter._print_Contains:) def _print_Contains(self, e): (definition of MathMLPresentationPrinter._print_HilbertSpace:) def _print_HilbertSpace(self, e): (definition of MathMLPresentationPrinter._print_ComplexSpace:) def _print_ComplexSpace(self, e): (definition of MathMLPresentationPrinter._print_FockSpace:) def _print_FockSpace(self, e): [end of new definitions in sympy/printing/mathml.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-17064	17,064	sympy/sympy	1.5	411757c159e16a56b5ad8141cb07dc32f4277caa	2019-06-20T19:56:16Z	diff --git a/sympy/series/formal.py b/sympy/series/formal.py index 2065b385f46f..c6a6f1a225fa 100644 --- a/sympy/series/formal.py +++ b/sympy/series/formal.py @@ -18,6 +18,7 @@ from sympy.core.sympify import sympify from sympy.discrete.convolutions import convolution from sympy.functions.combinatorial.factorials import binomial, factorial, rf +from sympy.functions.combinatorial.numbers import bell from sympy.functions.elementary.integers import floor, frac, ceiling from sympy.functions.elementary.miscellaneous import Min, Max from sympy.functions.elementary.piecewise import Piecewise @@ -943,6 +944,14 @@ def __new__(cls, args): args = map(sympify, args) return Expr.__new__(cls, args) + def __init__(self, args): + ak = args[4][0] + k = ak.variables[0] + self.ak_seq = sequence(ak.formula, (k, 1, oo)) + self.fact_seq = sequence(factorial(k), (k, 1, oo)) + self.bell_coeff_seq = self.ak_seq self.fact_seq + self.sign_seq = sequence((-1, 1), (k, 1, oo)) + @property def function(self): return self.args[0] @@ -1171,6 +1180,7 @@ def product(self, other, x=None, n=6): sympy.discrete.convolutions """ + if x is None: x = self.x if n is None: @@ -1178,7 +1188,7 @@ def product(self, other, x=None, n=6): other = sympify(other) - if not isinstance(other, FormalPowerSeries): + if not isinstance(other, FormalPowerSeries): raise ValueError("Both series should be an instance of FormalPowerSeries" " class.") @@ -1207,6 +1217,186 @@ def product(self, other, x=None, n=6): return Add((terms_seq[:n])) + Order(self.xk.coeff(n), (self.x, self.x0)) + def coeff_bell(self, n): + r""" + self.coeff_bell(n) returns a sequence of Bell polynomials of the second kind. + Note that ``n`` should be a integer. + + The second kind of Bell polynomials (are sometimes called "partial" Bell + polynomials or incomplete Bell polynomials) are defined as + + .. math:: B_{n,k}(x_1, x_2,\dotsc x_{n-k+1}) = + \sum_{j_1+j_2+j_2+\dotsb=k \atop j_1+2j_2+3j_2+\dotsb=n} + \frac{n!}{j_1!j_2!\dotsb j_{n-k+1}!} + \left(\frac{x_1}{1!} \right)^{j_1} + \left(\frac{x_2}{2!} \right)^{j_2} \dotsb + \left(\frac{x_{n-k+1}}{(n-k+1)!} \right) ^{j_{n-k+1}}. + + ``bell(n, k, (x1, x2, ...))`` gives Bell polynomials of the second kind, + `B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1})`. + + See Also + ======== + + sympy.functions.combinatorial.numbers.bell + + """ + + inner_coeffs = [bell(n, j, tuple(self.bell_coeff_seq[:n-j+1])) for j in range(1, n+1)] + + k = Dummy('k') + return sequence(tuple(inner_coeffs), (k, 1, oo)) + + def compose(self, other, x=None, n=6): + r""" + Returns the truncated terms of the formal power series of the composed function, + up to specified `n`. + + If `f` and `g` are two formal power series of two different functions, + then the coefficient sequence ``ak`` of the composed formal power series `fp` + will be as follows. + + .. math:: + + \sum\limits_{k=0}^{n} b_k B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1}) + + Parameters + ========== + + n : Number, optional + Specifies the order of the term up to which the polynomial should + be truncated. + + Examples + ======== + + >>> from sympy import fps, sin, exp, bell + >>> from sympy.abc import x + >>> f1 = fps(exp(x)) + >>> f2 = fps(sin(x)) + + >>> f1.compose(f2, x) + 1 + x + x2/2 - x4/8 - x5/15 + O(x6) + + >>> f1.compose(f2, x, n=8) + 1 + x + x2/2 - x4/8 - x5/15 - x6/240 + x7/90 + O(x8) + + See Also + ======== + + sympy.functions.combinatorial.numbers.bell + + References + ========== + + .. [1] Comtet, Louis: Advanced combinatorics; the art of finite and infinite expansions. Reidel, 1974. + + """ + + if x is None: + x = self.x + if n is None: + return iter(self) + + other = sympify(other) + + if not isinstance(other, FormalPowerSeries): + raise ValueError("Both series should be an instance of FormalPowerSeries" + " class.") + + if self.dir != other.dir: + raise ValueError("Both series should be calculated from the" + " same direction.") + elif self.x0 != other.x0: + raise ValueError("Both series should be calculated about the" + " same point.") + + elif self.x != other.x: + raise ValueError("Both series should have the same symbol.") + + f, g = self.function, other.function + if other._eval_term(0).as_coeff_mul(other.x)[0] is not S.Zero: + raise ValueError("The formal power series of the inner function should not have any " + "constant coefficient term.") + + terms = [] + + for i in range(1, n): + bell_seq = other.coeff_bell(i) + seq = (self.bell_coeff_seq * bell_seq) + terms.append(Add((seq[:i])) self.xk.coeff(i) / self.fact_seq[i-1]) + + return self._eval_term(0) + Add(terms) + Order(self.xk.coeff(n), (self.x, self.x0)) + + def inverse(self, x=None, n=6): + r""" + Returns the truncated terms of the inverse of the formal power series, + up to specified `n`. + + If `f` and `g` are two formal power series of two different functions, + then the coefficient sequence ``ak`` of the composed formal power series `fp` + will be as follows. + + .. math:: + + \sum\limits_{k=0}^{n} (-1)^{k} x_0^{-k-1} B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1}) + + Parameters + ========== + + n : Number, optional + Specifies the order of the term up to which the polynomial should + be truncated. + + Examples + ======== + + >>> from sympy import fps, exp, cos, bell + >>> from sympy.abc import x + >>> f1 = fps(exp(x)) + >>> f2 = fps(cos(x)) + + >>> f1.inverse(x) + 1 - x + x2/2 - x3/6 + x4/24 - x5/120 + O(x6) + + >>> f2.inverse(x, n=8) + 1 + x2/2 + 5x*4/24 + 61x6/720 + O(x8) + + See Also + ======== + + sympy.functions.combinatorial.numbers.bell + + References + ========== + + .. [1] Comtet, Louis: Advanced combinatorics; the art of finite and infinite expansions. Reidel, 1974. + + """ + + if x is None: + x = self.x + if n is None: + return iter(self) + + f = self.function + if self._eval_term(0) is S.Zero: + raise ValueError("Constant coefficient should exist for an inverse of a formal" + " power series to exist.") + inv = self._eval_term(0) + + k = Dummy('k') + terms = [] + inv_seq = sequence(inv ** (-(k + 1)), (k, 1, oo)) + aux_seq = self.sign_seq * self.fact_seq * inv_seq + + for i in range(1, n): + bell_seq = self.coeff_bell(i) + seq = (aux_seq * bell_seq) + terms.append(Add((seq[:i])) self.xk.coeff(i) / self.fact_seq[i-1]) + + return self._eval_term(0) + Add(*terms) + Order(self.xk.coeff(n), (self.x, self.x0)) + def __add__(self, other): other = sympify(other)	diff --git a/sympy/series/tests/test_formal.py b/sympy/series/tests/test_formal.py index 233e3382a7ef..86626c1ea332 100644 --- a/sympy/series/tests/test_formal.py +++ b/sympy/series/tests/test_formal.py @@ -519,3 +519,35 @@ def test_fps__convolution(): assert f1.product(f2, x, 3) == x + x2 + O(x3) assert f1.product(f2, x, 4) == x + x2 + x3/3 + O(x*4) assert f1.product(f3, x, 4) == x - 2x3/3 + O(x4) + +def test_fps__composition(): + f1, f2, f3 = fps(exp(x)), fps(sin(x)), fps(cos(x)) + + raises(ValueError, lambda: f1.compose(sin(x), x)) + raises(ValueError, lambda: f1.compose(fps(sin(x), dir=-1), x, 4)) + raises(ValueError, lambda: f1.compose(fps(sin(x), x0=1), x, 4)) + raises(ValueError, lambda: f1.compose(fps(sin(y)), x, 4)) + + raises(ValueError, lambda: f1.compose(f3, x)) + raises(ValueError, lambda: f2.compose(f3, x)) + + assert f1.compose(f2, x) == 1 + x + x2/2 - x4/8 - x5/15 + O(x6) + assert f1.compose(f2, x, n=4) == 1 + x + x2/2 + O(x4) + assert f1.compose(f2, x, n=8) == \ + 1 + x + x2/2 - x4/8 - x5/15 - x6/240 + x7/90 + O(x8) + + assert f2.compose(f2, x, n=4) == x - x3/3 + O(x4) + assert f2.compose(f2, x, n=8) == x - x3/3 + x5/10 - 8x7/315 + O(x8) + +def test_fps__inverse(): + f1, f2, f3 = fps(sin(x)), fps(exp(x)), fps(cos(x)) + + raises(ValueError, lambda: f1.inverse(x)) + raises(ValueError, lambda: f1.inverse(x, n=8)) + + assert f2.inverse(x) == 1 - x + x2/2 - x3/6 + x4/24 - x5/120 + O(x6) + assert f2.inverse(x, n=8) == \ + 1 - x + x2/2 - x3/6 + x4/24 - x5/120 + x6/720 - x7/5040 + O(x8) + + assert f3.inverse(x) == 1 + x2/2 + 5x4/24 + O(x6) + assert f3.inverse(x, n=8) == 1 + x*2/2 + 5x*4/24 + 61x6/720 + O(x8)		[ { "components": [ { "doc": "", "lines": [ 947, 953 ], "name": "FormalPowerSeries.__init__", "signature": "def __init__(self, *args):", "type": "function" }, { "doc": "self.coeff_bell(n) returns a sequence of Bell polyn...	[ "test_fps__composition" ]	[ "test_rational_algorithm", "test_rational_independent", "test_simpleDE", "test_exp_re", "test_hyper_re", "test_fps", "test_fps_shift", "test_fps__Add_expr", "test_fps__asymptotic", "test_fps__fractional", "test_fps__logarithmic_singularity", "test_fps_symbolic", "test_fps__slow", "test_fps...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [GSoC] Implementation of composition and inversion of formal power series <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs Fixes Issue #16975 . #### Brief description of what is fixed or changed Composition of two `FormalPowerSeries` objects have been implemented. Presently, it takes in a order `n` term, and prints all the terms in the composed resultant fps upto order. No FormalPowerSeries object is being returned as of now. For `composition`, there exists a closed form expression for the resultant power series, where the resultant coefficient sequence `ak` involves Bell polynomials, as follows -- ![image](https://user-images.githubusercontent.com/28482640/58986902-ffd1ee80-87fb-11e9-95d5-bf4965dd4c1c.png) For `inversion`, there exists a similar `Bell-polynomial` closed form expression. #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * series * Implemented composition and inversion operation of two formal power series in `sympy.series.formal` <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/series/formal.py] (definition of FormalPowerSeries.__init__:) def __init__(self, args): (definition of FormalPowerSeries.coeff_bell:) def coeff_bell(self, n): """self.coeff_bell(n) returns a sequence of Bell polynomials of the second kind. Note that ``n`` should be a integer. The second kind of Bell polynomials (are sometimes called "partial" Bell polynomials or incomplete Bell polynomials) are defined as .. math:: B_{n,k}(x_1, x_2,\dotsc x_{n-k+1}) = \sum_{j_1+j_2+j_2+\dotsb=k \atop j_1+2j_2+3j_2+\dotsb=n} \frac{n!}{j_1!j_2!\dotsb j_{n-k+1}!} \left(\frac{x_1}{1!} \right)^{j_1} \left(\frac{x_2}{2!} \right)^{j_2} \dotsb \left(\frac{x_{n-k+1}}{(n-k+1)!} \right) ^{j_{n-k+1}}. ``bell(n, k, (x1, x2, ...))`` gives Bell polynomials of the second kind, `B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1})`. See Also ======== sympy.functions.combinatorial.numbers.bell""" (definition of FormalPowerSeries.compose:) def compose(self, other, x=None, n=6): """Returns the truncated terms of the formal power series of the composed function, up to specified `n`. If `f` and `g` are two formal power series of two different functions, then the coefficient sequence ``ak`` of the composed formal power series `fp` will be as follows. .. math:: \sum\limits_{k=0}^{n} b_k B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1}) Parameters ========== n : Number, optional Specifies the order of the term up to which the polynomial should be truncated. Examples ======== >>> from sympy import fps, sin, exp, bell >>> from sympy.abc import x >>> f1 = fps(exp(x)) >>> f2 = fps(sin(x)) >>> f1.compose(f2, x) 1 + x + x2/2 - x4/8 - x5/15 + O(x6) >>> f1.compose(f2, x, n=8) 1 + x + x2/2 - x4/8 - x5/15 - x6/240 + x7/90 + O(x8) See Also ======== sympy.functions.combinatorial.numbers.bell References ========== .. [1] Comtet, Louis: Advanced combinatorics; the art of finite and infinite expansions. Reidel, 1974.""" (definition of FormalPowerSeries.inverse:) def inverse(self, x=None, n=6): """Returns the truncated terms of the inverse of the formal power series, up to specified `n`. If `f` and `g` are two formal power series of two different functions, then the coefficient sequence ``ak`` of the composed formal power series `fp` will be as follows. .. math:: \sum\limits_{k=0}^{n} (-1)^{k} x_0^{-k-1} B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1}) Parameters ========== n : Number, optional Specifies the order of the term up to which the polynomial should be truncated. Examples ======== >>> from sympy import fps, exp, cos, bell >>> from sympy.abc import x >>> f1 = fps(exp(x)) >>> f2 = fps(cos(x)) >>> f1.inverse(x) 1 - x + x2/2 - x3/6 + x4/24 - x5/120 + O(x6) >>> f2.inverse(x, n=8) 1 + x2/2 + 5x4/24 + 61x6/720 + O(x8) See Also ======== sympy.functions.combinatorial.numbers.bell References ========== .. [1] Comtet, Louis: Advanced combinatorics; the art of finite and infinite expansions. Reidel, 1974.""" [end of new definitions in sympy/series/formal.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-17041	17,041	sympy/sympy	1.5	dec26834d188f14f2647b1687837b1e87d92a8e5	2019-06-17T17:02:44Z	diff --git a/doc/src/modules/codegen.rst b/doc/src/modules/codegen.rst index 0ec801865bb8..6ad67e51df09 100644 --- a/doc/src/modules/codegen.rst +++ b/doc/src/modules/codegen.rst @@ -548,6 +548,9 @@ Classes and functions for rewriting expressions (sympy.codegen.rewriting) .. automodule:: sympy.codegen.rewriting :members: +.. automodule:: sympy.codegen.matrix_nodes + :members: + Tools for simplifying expressions using approximations (sympy.codegen.approximations) ------------------------------------------------------------------------------------- diff --git a/sympy/codegen/matrix_nodes.py b/sympy/codegen/matrix_nodes.py new file mode 100644 index 000000000000..3acc81c25706 --- /dev/null +++ b/sympy/codegen/matrix_nodes.py @@ -0,0 +1,65 @@ +""" +Additional AST nodes for operations on matrices. The nodes in this module +are meant to represent optimization of matrix expressions within codegen's +target languages that cannot be represented by SymPy expressions. + +As an example, we can use :meth:`sympy.codegen.rewriting.optimize` and the +``matin_opt`` optimization provided in :mod:`sympy.codegen.rewriting` to +transform matrix multiplication under certain assumptions: + + >>> from sympy import symbols, MatrixSymbol + >>> n = symbols('n', integer=True) + >>> A = MatrixSymbol('A', n, n) + >>> x = MatrixSymbol('x', n, 1) + >>> expr = A*(-1) x + >>> from sympy.assumptions import assuming, Q + >>> from sympy.codegen.rewriting import matinv_opt, optimize + >>> with assuming(Q.fullrank(A)): + ... optimize(expr, [matinv_opt]) + MatrixSolve(A, vector=x) +""" + +from .ast import Token +from sympy.matrices import MatrixExpr +from sympy.core.sympify import sympify + + +class MatrixSolve(Token, MatrixExpr): + """Represents an operation to solve a linear matrix equation. + + Parameters + ========== + + matrix : MatrixSymbol + + Matrix representing the coefficients of variables in the linear + equation. This matrix must be square and full-rank (i.e. all columns must + be linearly independent) for the solving operation to be valid. + + vector : MatrixSymbol + + One-column matrix representing the solutions to the equations + represented in ``matrix``. + + Examples + ======== + + >>> from sympy import symbols, MatrixSymbol + >>> from sympy.codegen.matrix_nodes import MatrixSolve + >>> n = symbols('n', integer=True) + >>> A = MatrixSymbol('A', n, n) + >>> x = MatrixSymbol('x', n, 1) + >>> from sympy.printing.pycode import NumPyPrinter + >>> NumPyPrinter().doprint(MatrixSolve(A, x)) + 'numpy.linalg.solve(A, x)' + >>> from sympy.printing import octave_code + >>> octave_code(MatrixSolve(A, x)) + 'A \\\\ x' + + """ + __slots__ = ['matrix', 'vector'] + + _construct_matrix = staticmethod(sympify) + + def __init__(self, matrix, vector): + self.shape = self.vector.shape diff --git a/sympy/codegen/rewriting.py b/sympy/codegen/rewriting.py index 09d45c8ce627..fee8ee35ba79 100644 --- a/sympy/codegen/rewriting.py +++ b/sympy/codegen/rewriting.py @@ -33,10 +33,13 @@ from __future__ import (absolute_import, division, print_function) from itertools import chain from sympy import log, exp, Max, Min, Wild, expand_log, Dummy +from sympy.assumptions import Q, ask from sympy.codegen.cfunctions import log1p, log2, exp2, expm1 +from sympy.codegen.matrix_nodes import MatrixSolve from sympy.core.expr import UnevaluatedExpr from sympy.core.mul import Mul from sympy.core.power import Pow +from sympy.matrices.expressions.matexpr import MatrixSymbol from sympy.utilities.iterables import sift @@ -228,5 +231,26 @@ def create_expand_pow_optimization(limit): 1/UnevaluatedExpr(Mul(([p.base]-p.exp), evaluate=False)) )) +# Optimization procedures for turning A*(-1) x into MatrixSolve(A, x) +def _matinv_predicate(expr): + # TODO: We should be able to support more than 2 elements + if expr.is_MatMul and len(expr.args) == 2: + left, right = expr.args + if left.is_Inverse and right.shape[1] == 1: + inv_arg = left.arg + if isinstance(inv_arg, MatrixSymbol): + return bool(ask(Q.fullrank(left.arg))) + + return False + +def _matinv_transform(expr): + left, right = expr.args + inv_arg = left.arg + return MatrixSolve(inv_arg, right) + + +matinv_opt = ReplaceOptim(_matinv_predicate, _matinv_transform) + + # Collections of optimizations: optims_c99 = (expm1_opt, log1p_opt, exp2_opt, log2_opt, log2const_opt) diff --git a/sympy/printing/octave.py b/sympy/printing/octave.py index ac63d5ebbff4..95504f568c43 100644 --- a/sympy/printing/octave.py +++ b/sympy/printing/octave.py @@ -233,6 +233,10 @@ def _print_MatPow(self, expr): return '%s^%s' % (self.parenthesize(expr.base, PREC), self.parenthesize(expr.exp, PREC)) + def _print_MatrixSolve(self, expr): + PREC = precedence(expr) + return "%s \\ %s" % (self.parenthesize(expr.matrix, PREC), + self.parenthesize(expr.vector, PREC)) def _print_Pi(self, expr): return 'pi' diff --git a/sympy/printing/precedence.py b/sympy/printing/precedence.py index 063c1cf626d7..7eb4eac6dade 100644 --- a/sympy/printing/precedence.py +++ b/sympy/printing/precedence.py @@ -40,6 +40,7 @@ "NegativeInfinity": PRECEDENCE["Add"], "MatAdd": PRECEDENCE["Add"], "MatPow": PRECEDENCE["Pow"], + "MatrixSolve": PRECEDENCE["Mul"], "TensAdd": PRECEDENCE["Add"], # As soon as `TensMul` is a subclass of `Mul`, remove this: "TensMul": PRECEDENCE["Mul"], diff --git a/sympy/printing/pycode.py b/sympy/printing/pycode.py index e9ecd9e32db4..d41802eb9588 100644 --- a/sympy/printing/pycode.py +++ b/sympy/printing/pycode.py @@ -626,6 +626,11 @@ def _print_DotProduct(self, expr): self._print(arg1), self._print(arg2)) + def _print_MatrixSolve(self, expr): + return "%s(%s, %s)" % (self._module_format('numpy.linalg.solve'), + self._print(expr.matrix), + self._print(expr.vector)) + def _print_Piecewise(self, expr): "Piecewise function printer" exprs = '[{0}]'.format(','.join(self._print(arg.expr) for arg in expr.args))	diff --git a/sympy/codegen/tests/test_rewriting.py b/sympy/codegen/tests/test_rewriting.py index 93da5092ab86..da42a08819d9 100644 --- a/sympy/codegen/tests/test_rewriting.py +++ b/sympy/codegen/tests/test_rewriting.py @@ -1,11 +1,13 @@ from __future__ import (absolute_import, print_function) -from sympy import log, exp, Symbol, Pow, sin +from sympy import log, exp, Symbol, Pow, sin, MatrixSymbol +from sympy.assumptions import assuming, Q from sympy.printing.ccode import ccode +from sympy.codegen.matrix_nodes import MatrixSolve from sympy.codegen.cfunctions import log2, exp2, expm1, log1p from sympy.codegen.rewriting import ( optimize, log2_opt, exp2_opt, expm1_opt, log1p_opt, optims_c99, - create_expand_pow_optimization + create_expand_pow_optimization, matinv_opt ) from sympy.utilities.pytest import XFAIL @@ -172,3 +174,13 @@ def test_create_expand_pow_optimization(): assert cc(x4 - x2) == '-xx + xxxx' i = Symbol('i', integer=True) assert cc(xi - x2) == 'pow(x, i) - xx' + + +def test_matsolve(): + n = Symbol('n', integer=True) + A = MatrixSymbol('A', n, n) + x = MatrixSymbol('x', n, 1) + + with assuming(Q.fullrank(A)): + assert optimize(A(-1) x, [matinv_opt]) == MatrixSolve(A, x) + assert optimize(A*(-1) x + x, [matinv_opt]) == MatrixSolve(A, x) + x diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index a8f7f03755c2..1a03df681874 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -4503,6 +4503,14 @@ def test_sympy__codegen__fnodes__literal_dp(): assert _test_args(literal_dp(1)) +def test_sympy__codegen__matrix_nodes__MatrixSolve(): + from sympy.matrices import MatrixSymbol + from sympy.codegen.matrix_nodes import MatrixSolve + A = MatrixSymbol('A', 3, 3) + v = MatrixSymbol('x', 3, 1) + assert _test_args(MatrixSolve(A, v)) + + def test_sympy__vector__coordsysrect__CoordSys3D(): from sympy.vector.coordsysrect import CoordSys3D assert _test_args(CoordSys3D('C')) diff --git a/sympy/printing/tests/test_numpy.py b/sympy/printing/tests/test_numpy.py index 13627064ecb4..bf6d347b0195 100644 --- a/sympy/printing/tests/test_numpy.py +++ b/sympy/printing/tests/test_numpy.py @@ -4,6 +4,7 @@ ) from sympy import eye from sympy.abc import x, i, j, a, b, c, d +from sympy.codegen.matrix_nodes import MatrixSolve from sympy.codegen.cfunctions import log1p, expm1, hypot, log10, exp2, log2, Cbrt, Sqrt from sympy.codegen.array_utils import (CodegenArrayContraction, CodegenArrayTensorProduct, CodegenArrayDiagonal, @@ -226,6 +227,28 @@ def test_sqrt(): skip("NumPy not installed") assert abs(lambdify((a,), sqrt(a), 'numpy')(4) - 2) < 1e-16 + +def test_matsolve(): + if not np: + skip("NumPy not installed") + + M = MatrixSymbol("M", 3, 3) + x = MatrixSymbol("x", 3, 1) + + expr = M*(-1) x + x + matsolve_expr = MatrixSolve(M, x) + x + + f = lambdify((M, x), expr) + f_matsolve = lambdify((M, x), matsolve_expr) + + m0 = np.array([[1, 2, 3], [3, 2, 5], [5, 6, 7]]) + assert np.linalg.matrix_rank(m0) == 3 + + x0 = np.array([3, 4, 5]) + + assert np.allclose(f_matsolve(m0, x0), f(m0, x0)) + + def test_issue_15601(): if not np: skip("Numpy not installed") diff --git a/sympy/printing/tests/test_octave.py b/sympy/printing/tests/test_octave.py index 0ff33b1b3616..409354e8d65e 100644 --- a/sympy/printing/tests/test_octave.py +++ b/sympy/printing/tests/test_octave.py @@ -1,6 +1,7 @@ from sympy.core import (S, pi, oo, symbols, Function, Rational, Integer, Tuple, Symbol) from sympy.core import EulerGamma, GoldenRatio, Catalan, Lambda, Mul, Pow +from sympy.codegen.matrix_nodes import MatrixSolve from sympy.functions import (arg, atan2, bernoulli, beta, ceiling, chebyshevu, chebyshevt, conjugate, DiracDelta, exp, expint, factorial, floor, harmonic, Heaviside, im, @@ -251,6 +252,12 @@ def test_MatrixSymbol(): assert mcode(A*(S.Half)) == "A^(1/2)" +def test_MatrixSolve(): + n = Symbol('n', integer=True) + A = MatrixSymbol('A', n, n) + x = MatrixSymbol('x', n, 1) + assert mcode(MatrixSolve(A, x)) == "A \\ x" + def test_special_matrices(): assert mcode(6Identity(3)) == "6eye(3)" diff --git a/sympy/printing/tests/test_pycode.py b/sympy/printing/tests/test_pycode.py index fbb3607b4286..8e20f3469a15 100644 --- a/sympy/printing/tests/test_pycode.py +++ b/sympy/printing/tests/test_pycode.py @@ -3,6 +3,7 @@ from sympy.codegen import Assignment from sympy.codegen.ast import none +from sympy.codegen.matrix_nodes import MatrixSolve from sympy.core import Expr, Mod, symbols, Eq, Le, Gt, zoo, oo, Rational from sympy.core.singleton import S from sympy.core.numbers import pi @@ -72,6 +73,10 @@ def test_NumPyPrinter(): assert p.doprint(A(-1)) == "numpy.linalg.inv(A)" assert p.doprint(A5) == "numpy.linalg.matrix_power(A, 5)" + u = MatrixSymbol('x', 2, 1) + v = MatrixSymbol('y', 2, 1) + assert p.doprint(MatrixSolve(A, u)) == 'numpy.linalg.solve(A, x)' + assert p.doprint(MatrixSolve(A, u) + v) == 'numpy.linalg.solve(A, x) + y' # Workaround for numpy negative integer power errors assert p.doprint(x-1) == 'x(-1.0)' assert p.doprint(x-2) == 'x*(-2.0)'	diff --git a/doc/src/modules/codegen.rst b/doc/src/modules/codegen.rst index 0ec801865bb8..6ad67e51df09 100644 --- a/doc/src/modules/codegen.rst +++ b/doc/src/modules/codegen.rst @@ -548,6 +548,9 @@ Classes and functions for rewriting expressions (sympy.codegen.rewriting) .. automodule:: sympy.codegen.rewriting :members: +.. automodule:: sympy.codegen.matrix_nodes + :members: + Tools for simplifying expressions using approximations (sympy.codegen.approximations) -------------------------------------------------------------------------------------	[ { "components": [ { "doc": "Represents an operation to solve a linear matrix equation.\n\nParameters\n==========\n\nmatrix : MatrixSymbol\n\n Matrix representing the coefficients of variables in the linear\n equation. This matrix must be square and full-rank (i.e. all columns must\n be linearly...	[ "test_log2_opt", "test_exp2_opt", "test_expm1_opt", "test_log1p_opt", "test_optims_c99", "test_create_expand_pow_optimization", "test_sympy__codegen__matrix_nodes__MatrixSolve", "test_numpy_piecewise_regression", "test_Integer", "test_Rational", "test_Function", "test_Function_change_name", ...	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add optimization of numpy code involving matrix inverses <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### Brief description of what is fixed or changed Adds an `optimization` option to the code printer base class that executes any `codegen.rewriting` optimizations the printer object might have. Also adds an optimization to the numpy printer that uses the assumption system to rewrite the multiplication of a matrix and a vector as the faster `np.linalg.solve` when appropriate. For example: ```python3 >>> from sympy.assumptions import assuming, Q >>> from sympy.matrices import MatrixSymbol >>> from sympy.printing.pycode import NumPyPrinter >>> A = MatrixSymbol('A', 2, 2) >>> x = MatrixSymbol('x', 2, 1) >>> p = NumPyPrinter(settings={'optimize' : True}) >>> print(p.doprint(A*(-1) x)) (numpy.linalg.inv(A)).dot(x) >>> with assuming(Q.fullrank(A)): ... p.doprint(A*(-1) x) numpy.linalg.solve(A, x) ``` #### Other comments This PR is mostly meant as an exploration of how (and whether) the `codegen.rewriting` module is enough for generating optimizations. I'd appreciate comments and suggestions about this approach. #### Release Notes <!-- BEGIN RELEASE NOTES --> * printing * Add support for optimizations to numpy printer. * The numpy and octave printers print matrix expressions like `A*-1x` using a `solve`. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/codegen/matrix_nodes.py] (definition of MatrixSolve:) class MatrixSolve(Token, MatrixExpr): """Represents an operation to solve a linear matrix equation. Parameters ========== matrix : MatrixSymbol Matrix representing the coefficients of variables in the linear equation. This matrix must be square and full-rank (i.e. all columns must be linearly independent) for the solving operation to be valid. vector : MatrixSymbol One-column matrix representing the solutions to the equations represented in ``matrix``. Examples ======== >>> from sympy import symbols, MatrixSymbol >>> from sympy.codegen.matrix_nodes import MatrixSolve >>> n = symbols('n', integer=True) >>> A = MatrixSymbol('A', n, n) >>> x = MatrixSymbol('x', n, 1) >>> from sympy.printing.pycode import NumPyPrinter >>> NumPyPrinter().doprint(MatrixSolve(A, x)) 'numpy.linalg.solve(A, x)' >>> from sympy.printing import octave_code >>> octave_code(MatrixSolve(A, x)) 'A \\ x'""" (definition of MatrixSolve.__init__:) def __init__(self, matrix, vector): [end of new definitions in sympy/codegen/matrix_nodes.py] [start of new definitions in sympy/codegen/rewriting.py] (definition of _matinv_predicate:) def _matinv_predicate(expr): (definition of _matinv_transform:) def _matinv_transform(expr): [end of new definitions in sympy/codegen/rewriting.py] [start of new definitions in sympy/printing/octave.py] (definition of OctaveCodePrinter._print_MatrixSolve:) def _print_MatrixSolve(self, expr): [end of new definitions in sympy/printing/octave.py] [start of new definitions in sympy/printing/pycode.py] (definition of NumPyPrinter._print_MatrixSolve:) def _print_MatrixSolve(self, expr): [end of new definitions in sympy/printing/pycode.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
joblib__joblib-894	894	joblib/joblib	null	c2087dbdeec9824c45822670395a8a0c45be2211	2019-06-14T18:33:04Z	diff --git a/CHANGES.rst b/CHANGES.rst index 5bf9c956e..e191018d6 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -4,11 +4,14 @@ Latest changes In development -------------- +- Allow caching co-routines with `Memory.cache`. + https://github.com/joblib/joblib/pull/894 + - Try to cast ``n_jobs`` to int in parallel and raise an error if it fails. This means that ``n_jobs=2.3`` will now result in ``effective_n_jobs=2`` instead of failing. https://github.com/joblib/joblib/pull/1539 - + - Ensure that errors in the task generator given to Parallel's call are raised in the results consumming thread. https://github.com/joblib/joblib/pull/1491 diff --git a/continuous_integration/install.sh b/continuous_integration/install.sh index c6fed2883..9668b7474 100755 --- a/continuous_integration/install.sh +++ b/continuous_integration/install.sh @@ -34,7 +34,7 @@ else fi # Install pytest timeout to fasten failure in deadlocking tests -PIP_INSTALL_PACKAGES="pytest-timeout threadpoolctl" +PIP_INSTALL_PACKAGES="pytest-timeout pytest-asyncio==0.21.1 threadpoolctl" if [ -n "$NUMPY_VERSION" ]; then # We want to ensure no memory copies are performed only when numpy is diff --git a/joblib/_store_backends.py b/joblib/_store_backends.py index ce9146098..68e207c17 100644 --- a/joblib/_store_backends.py +++ b/joblib/_store_backends.py @@ -7,6 +7,7 @@ import datetime import json import shutil +import time import warnings import collections import operator @@ -15,6 +16,7 @@ from .backports import concurrency_safe_rename from .disk import mkdirp, memstr_to_bytes, rm_subdirs +from .logger import format_time from . import numpy_pickle CacheItemInfo = collections.namedtuple('CacheItemInfo', @@ -151,12 +153,19 @@ class StoreBackendMixin(object): file-like object. """ - def load_item(self, path, verbose=1, msg=None): - """Load an item from the store given its path as a list of - strings.""" - full_path = os.path.join(self.location, path) + def load_item(self, call_id, verbose=1, timestamp=None, metadata=None): + """Load an item from the store given its id as a list of str.""" + full_path = os.path.join(self.location, call_id) if verbose > 1: + ts_string = ('{: <16}'.format(format_time(time.time() - timestamp)) + if timestamp is not None else '') + signature = os.path.basename(call_id[0]) + if metadata is not None and 'input_args' in metadata: + kwargs = ', '.join('{}={}'.format(item) + for item in metadata['input_args'].items()) + signature += '({})'.format(kwargs) + msg = '[Memory]{}: Loading {}'.format(ts_string, signature) if verbose < 10: print('{0}...'.format(msg)) else: @@ -178,11 +187,10 @@ def load_item(self, path, verbose=1, msg=None): item = numpy_pickle.load(filename, mmap_mode=mmap_mode) return item - def dump_item(self, path, item, verbose=1): - """Dump an item in the store at the path given as a list of - strings.""" + def dump_item(self, call_id, item, verbose=1): + """Dump an item in the store at the id given as a list of str.""" try: - item_path = os.path.join(self.location, path) + item_path = os.path.join(self.location, call_id) if not self._item_exists(item_path): self.create_location(item_path) filename = os.path.join(item_path, 'output.pkl') @@ -210,39 +218,37 @@ def write_func(to_write, dest_filename): CacheWarning ) - def clear_item(self, path): - """Clear the item at the path, given as a list of strings.""" - item_path = os.path.join(self.location, path) + def clear_item(self, call_id): + """Clear the item at the id, given as a list of str.""" + item_path = os.path.join(self.location, call_id) if self._item_exists(item_path): self.clear_location(item_path) - def contains_item(self, path): - """Check if there is an item at the path, given as a list of - strings""" - item_path = os.path.join(self.location, path) + def contains_item(self, call_id): + """Check if there is an item at the id, given as a list of str.""" + item_path = os.path.join(self.location, call_id) filename = os.path.join(item_path, 'output.pkl') return self._item_exists(filename) - def get_item_info(self, path): + def get_item_info(self, call_id): """Return information about item.""" - return {'location': os.path.join(self.location, - path)} + return {'location': os.path.join(self.location, call_id)} - def get_metadata(self, path): + def get_metadata(self, call_id): """Return actual metadata of an item.""" try: - item_path = os.path.join(self.location, path) + item_path = os.path.join(self.location, call_id) filename = os.path.join(item_path, 'metadata.json') with self._open_item(filename, 'rb') as f: return json.loads(f.read().decode('utf-8')) except: # noqa: E722 return {} - def store_metadata(self, path, metadata): + def store_metadata(self, call_id, metadata): """Store metadata of a computation.""" try: - item_path = os.path.join(self.location, path) + item_path = os.path.join(self.location, call_id) self.create_location(item_path) filename = os.path.join(item_path, 'metadata.json') @@ -254,20 +260,20 @@ def write_func(to_write, dest_filename): except: # noqa: E722 pass - def contains_path(self, path): + def contains_path(self, call_id): """Check cached function is available in store.""" - func_path = os.path.join(self.location, path) + func_path = os.path.join(self.location, call_id) return self.object_exists(func_path) - def clear_path(self, path): + def clear_path(self, call_id): """Clear all items with a common path in the store.""" - func_path = os.path.join(self.location, path) + func_path = os.path.join(self.location, call_id) if self._item_exists(func_path): self.clear_location(func_path) - def store_cached_func_code(self, path, func_code=None): + def store_cached_func_code(self, call_id, func_code=None): """Store the code of the cached function.""" - func_path = os.path.join(self.location, path) + func_path = os.path.join(self.location, call_id) if not self._item_exists(func_path): self.create_location(func_path) @@ -276,19 +282,18 @@ def store_cached_func_code(self, path, func_code=None): with self._open_item(filename, 'wb') as f: f.write(func_code.encode('utf-8')) - def get_cached_func_code(self, path): + def get_cached_func_code(self, call_id): """Store the code of the cached function.""" - path += ['func_code.py', ] - filename = os.path.join(self.location, path) + filename = os.path.join(self.location, call_id, 'func_code.py') try: with self._open_item(filename, 'rb') as f: return f.read().decode('utf-8') except: # noqa: E722 raise - def get_cached_func_info(self, path): + def get_cached_func_info(self, call_id): """Return information related to the cached function if it exists.""" - return {'location': os.path.join(self.location, path)} + return {'location': os.path.join(self.location, call_id)} def clear(self): """Clear the whole store content.""" diff --git a/joblib/memory.py b/joblib/memory.py index 8171d24cb..6f87f8039 100644 --- a/joblib/memory.py +++ b/joblib/memory.py @@ -9,32 +9,28 @@ # License: BSD Style, 3 clauses. -from __future__ import with_statement +import asyncio +import datetime +import functools +import inspect import logging import os -from textwrap import dedent -import time import pathlib import pydoc import re -import functools +import textwrap +import time +import tokenize import traceback import warnings -import inspect import weakref -from datetime import timedelta - -from tokenize import open as open_py_source -# Local imports from . import hashing -from .func_inspect import get_func_code, get_func_name, filter_args -from .func_inspect import format_call -from .func_inspect import format_signature -from .logger import Logger, format_time, pformat -from ._store_backends import StoreBackendBase, FileSystemStoreBackend from ._store_backends import CacheWarning # noqa - +from ._store_backends import FileSystemStoreBackend, StoreBackendBase +from .func_inspect import (filter_args, format_call, format_signature, + get_func_code, get_func_name) +from .logger import Logger, format_time, pformat FIRST_LINE_TEXT = "# first line:" @@ -141,45 +137,11 @@ def _store_backend_factory(backend, location, verbose=0, backend_options=None): return None -def _get_func_fullname(func): - """Compute the part of part associated with a function.""" - modules, funcname = get_func_name(func) - modules.append(funcname) - return os.path.join(modules) - - def _build_func_identifier(func): """Build a roughly unique identifier for the cached function.""" - parts = [] - if isinstance(func, str): - parts.append(func) - else: - parts.append(_get_func_fullname(func)) - + modules, funcname = get_func_name(func) # We reuse historical fs-like way of building a function identifier - return os.path.join(parts) - - -def _format_load_msg(func_id, args_id, timestamp=None, metadata=None): - """ Helper function to format the message when loading the results. - """ - signature = "" - try: - if metadata is not None: - args = ", ".join(['%s=%s' % (name, value) - for name, value - in metadata['input_args'].items()]) - signature = "%s(%s)" % (os.path.basename(func_id), args) - else: - signature = os.path.basename(func_id) - except KeyError: - pass - - if timestamp is not None: - ts_string = "{0: <16}".format(format_time(time.time() - timestamp)) - else: - ts_string = "" - return '[Memory]{0}: Loading {1}'.format(ts_string, str(signature)) + return os.path.join(modules, funcname) # An in-memory store to avoid looking at the disk-based function @@ -220,15 +182,10 @@ class MemorizedResult(Logger): timestamp, metadata: string for internal use only. """ - def __init__(self, location, func, args_id, backend='local', - mmap_mode=None, verbose=0, timestamp=None, metadata=None): + def __init__(self, location, call_id, backend='local', mmap_mode=None, + verbose=0, timestamp=None, metadata=None): Logger.__init__(self) - self.func_id = _build_func_identifier(func) - if isinstance(func, str): - self.func = func - else: - self.func = self.func_id - self.args_id = args_id + self._call_id = call_id self.store_backend = _store_backend_factory(backend, location, verbose=verbose) self.mmap_mode = mmap_mode @@ -236,13 +193,24 @@ def __init__(self, location, func, args_id, backend='local', if metadata is not None: self.metadata = metadata else: - self.metadata = self.store_backend.get_metadata( - [self.func_id, self.args_id]) + self.metadata = self.store_backend.get_metadata(self._call_id) self.duration = self.metadata.get('duration', None) self.verbose = verbose self.timestamp = timestamp + @property + def func(self): + return self.func_id + + @property + def func_id(self): + return self._call_id[0] + + @property + def args_id(self): + return self._call_id[1] + @property def argument_hash(self): warnings.warn( @@ -254,38 +222,29 @@ def argument_hash(self): def get(self): """Read value from cache and return it.""" - if self.verbose: - msg = _format_load_msg(self.func_id, self.args_id, - timestamp=self.timestamp, - metadata=self.metadata) - else: - msg = None - try: return self.store_backend.load_item( - [self.func_id, self.args_id], msg=msg, verbose=self.verbose) + self._call_id, + timestamp=self.timestamp, + metadata=self.metadata, + verbose=self.verbose + ) except ValueError as exc: new_exc = KeyError( "Error while trying to load a MemorizedResult's value. " "It seems that this folder is corrupted : {}".format( - os.path.join( - self.store_backend.location, self.func_id, - self.args_id) - )) + os.path.join(self.store_backend.location, self._call_id))) raise new_exc from exc def clear(self): """Clear value from cache""" - self.store_backend.clear_item([self.func_id, self.args_id]) + self.store_backend.clear_item(self._call_id) def __repr__(self): - return ('{class_name}(location="{location}", func="{func}", ' - 'args_id="{args_id}")' - .format(class_name=self.__class__.__name__, - location=self.store_backend.location, - func=self.func, - args_id=self.args_id - )) + return '{}(location="{}", func="{}", args_id="{}")'.format( + self.__class__.__name__, self.store_backend.location, + self._call_id + ) def __getstate__(self): state = self.__dict__.copy() @@ -369,6 +328,14 @@ def check_call_in_cache(self, args, kwargs): return False +############################################################################### +# class `AsyncNotMemorizedFunc` +############################################################################### +class AsyncNotMemorizedFunc(NotMemorizedFunc): + async def call_and_shelve(self, args, *kwargs): + return NotMemorizedResult(await self.func(args, *kwargs)) + + ############################################################################### # class `MemorizedFunc` ############################################################################### @@ -429,10 +396,8 @@ def __init__(self, func, location, backend='local', ignore=None, self.compress = compress self.func = func self.cache_validation_callback = cache_validation_callback - - if ignore is None: - ignore = [] - self.ignore = ignore + self.func_id = _build_func_identifier(func) + self.ignore = ignore if ignore is not None else [] self._verbose = verbose # retrieve store object from backend type and location. @@ -444,17 +409,13 @@ def __init__(self, func, location, backend='local', ignore=None, ) if self.store_backend is not None: # Create func directory on demand. - self.store_backend.store_cached_func_code([ - _build_func_identifier(self.func) - ]) + self.store_backend.store_cached_func_code([self.func_id]) - if timestamp is None: - timestamp = time.time() - self.timestamp = timestamp + self.timestamp = timestamp if timestamp is not None else time.time() try: functools.update_wrapper(self, func) except Exception: - " Objects like ufunc don't like that " + pass # Objects like ufunc don't like that if inspect.isfunction(func): doc = pydoc.TextDoc().document(func) # Remove blank line @@ -469,7 +430,7 @@ def __init__(self, func, location, backend='local', ignore=None, self._func_code_info = None self._func_code_id = None - def _is_in_cache_and_valid(self, path): + def _is_in_cache_and_valid(self, call_id): """Check if the function call is cached and valid for given arguments. - Compare the function code with the one from the cached function, @@ -485,22 +446,23 @@ def _is_in_cache_and_valid(self, path): return False # Check if this specific call is in the cache - if not self.store_backend.contains_item(path): + if not self.store_backend.contains_item(call_id): return False # Call the user defined cache validation callback - metadata = self.store_backend.get_metadata(path) + metadata = self.store_backend.get_metadata(call_id) if (self.cache_validation_callback is not None and not self.cache_validation_callback(metadata)): - self.store_backend.clear_item(path) + self.store_backend.clear_item(call_id) return False return True - def _cached_call(self, args, kwargs, shelving=False): + def _cached_call(self, args, kwargs, shelving): """Call wrapped function and cache result, or read cache if available. - This function returns the wrapped function output and some metadata. + This function returns the wrapped function output or a reference to + the cached result. Arguments: ---------- @@ -514,35 +476,22 @@ def _cached_call(self, args, kwargs, shelving=False): Returns ------- - output: value or tuple or None - Output of the wrapped function. - If shelving is True and the call has been already cached, - output is None. - - argument_hash: string - Hash of function arguments. - - metadata: dict - Some metadata about wrapped function call (see _persist_input()). + Output of the wrapped function if shelving is false, or a + MemorizedResult reference to the value if shelving is true. """ - func_id, args_id = self._get_output_identifiers(args, *kwargs) - metadata = None - msg = None - - # Whether or not the memorized function must be called - must_call = False + args_id = self._get_args_id(args, *kwargs) + call_id = (self.func_id, args_id) + _, func_name = get_func_name(self.func) + func_info = self.store_backend.get_cached_func_info([self.func_id]) + location = func_info['location'] if self._verbose >= 20: logging.basicConfig(level=logging.INFO) - _, name = get_func_name(self.func) - location = self.store_backend.get_cached_func_info([func_id])[ - 'location'] _, signature = format_signature(self.func, args, *kwargs) - self.info( - dedent( + textwrap.dedent( f""" - Querying {name} with signature + Querying {func_name} with signature {signature}. (argument hash {args_id}) @@ -555,58 +504,30 @@ def _cached_call(self, args, kwargs, shelving=False): # Compare the function code with the previous to see if the # function code has changed and check if the results are present in # the cache. - if self._is_in_cache_and_valid([func_id, args_id]): - try: - t0 = time.time() - if self._verbose: - msg = _format_load_msg(func_id, args_id, - timestamp=self.timestamp, - metadata=metadata) - - if not shelving: - # When shelving, we do not need to load the output - out = self.store_backend.load_item( - [func_id, args_id], - msg=msg, - verbose=self._verbose) - else: - out = None + if self._is_in_cache_and_valid(call_id): + if shelving: + return self._get_memorized_result(call_id) + try: + start_time = time.time() + output = self._load_item(call_id) if self._verbose > 4: - t = time.time() - t0 - _, name = get_func_name(self.func) - msg = '%s cache loaded - %s' % (name, format_time(t)) - print(max(0, (80 - len(msg))) '_' + msg) + self._print_duration(time.time() - start_time, + context='cache loaded ') + return output except Exception: # XXX: Should use an exception logger _, signature = format_signature(self.func, args, kwargs) self.warn('Exception while loading results for ' '{}\n {}'.format(signature, traceback.format_exc())) - must_call = True - else: - if self._verbose > 10: - _, name = get_func_name(self.func) - self.warn('Computing func {0}, argument hash {1} ' - 'in location {2}' - .format(name, args_id, - self.store_backend. - get_cached_func_info([func_id])['location'])) - must_call = True - - if must_call: - out, metadata = self.call(args, *kwargs) - if self.mmap_mode is not None: - # Memmap the output at the first call to be consistent with - # later calls - if self._verbose: - msg = _format_load_msg(func_id, args_id, - timestamp=self.timestamp, - metadata=metadata) - out = self.store_backend.load_item([func_id, args_id], msg=msg, - verbose=self._verbose) - - return (out, args_id, metadata) + if self._verbose > 10: + self.warn( + f"Computing func {func_name}, argument hash {args_id} " + f"in location {location}" + ) + + return self._call(call_id, args, kwargs, shelving) @property def func_code_info(self): @@ -646,13 +567,10 @@ def call_and_shelve(self, args, *kwargs): class "NotMemorizedResult" is used when there is no cache activated (e.g. location=None in Memory). """ - _, args_id, metadata = self._cached_call(args, kwargs, shelving=True) - return MemorizedResult(self.store_backend, self.func, args_id, - metadata=metadata, verbose=self._verbose - 1, - timestamp=self.timestamp) + return self._cached_call(args, kwargs, shelving=True) def __call__(self, args, *kwargs): - return self._cached_call(args, kwargs)[0] + return self._cached_call(args, kwargs, shelving=False) def __getstate__(self): # Make sure self.func's source is introspected prior to being pickled - @@ -682,22 +600,17 @@ def check_call_in_cache(self, args, *kwargs): Whether or not the result of the function has been cached for the input arguments that have been passed. """ - func_id, args_id = self._get_output_identifiers(args, *kwargs) - return self.store_backend.contains_item((func_id, args_id)) + call_id = (self.func_id, self._get_args_id(args, *kwargs)) + return self.store_backend.contains_item(call_id) # ------------------------------------------------------------------------ # Private interface # ------------------------------------------------------------------------ - def _get_argument_hash(self, args, *kwargs): + def _get_args_id(self, args, *kwargs): + """Return the input parameter hash of a result.""" return hashing.hash(filter_args(self.func, self.ignore, args, kwargs), - coerce_mmap=(self.mmap_mode is not None)) - - def _get_output_identifiers(self, args, *kwargs): - """Return the func identifier and input parameter hash of a result.""" - func_id = _build_func_identifier(self.func) - argument_hash = self._get_argument_hash(args, *kwargs) - return func_id, argument_hash + coerce_mmap=self.mmap_mode is not None) def _hash_func(self): """Hash a function to key the online cache""" @@ -712,12 +625,10 @@ def _write_func_code(self, func_code, first_line): # sometimes have several functions named the same way in a # file. This is bad practice, but joblib should be robust to bad # practice. - func_id = _build_func_identifier(self.func) func_code = u'%s %i\n%s' % (FIRST_LINE_TEXT, first_line, func_code) - self.store_backend.store_cached_func_code([func_id], func_code) + self.store_backend.store_cached_func_code([self.func_id], func_code) # Also store in the in-memory store of function hashes - is_named_callable = False is_named_callable = (hasattr(self.func, '__name__') and self.func.__name__ != '<lambda>') if is_named_callable: @@ -755,12 +666,9 @@ def _check_previous_func_code(self, stacklevel=2): # changing code and collision. We cannot inspect.getsource # because it is not reliable when using IPython's magic "%run". func_code, source_file, first_line = self.func_code_info - func_id = _build_func_identifier(self.func) - try: - old_func_code, old_first_line =\ - extract_first_line( - self.store_backend.get_cached_func_code([func_id])) + old_func_code, old_first_line = extract_first_line( + self.store_backend.get_cached_func_code([self.func_id])) except (IOError, OSError): # some backend can also raise OSError self._write_func_code(func_code, first_line) return False @@ -789,11 +697,10 @@ def _check_previous_func_code(self, stacklevel=2): # file has not changed, but the name we have is pointing to a new # code block. if not old_first_line == first_line and source_file is not None: - possible_collision = False if os.path.exists(source_file): _, func_name = get_func_name(self.func, resolv_alias=False) num_lines = len(func_code.split('\n')) - with open_py_source(source_file) as f: + with tokenize.open(source_file) as f: on_disk_func_code = f.readlines()[ old_first_line - 1:old_first_line - 1 + num_lines - 1] on_disk_func_code = ''.join(on_disk_func_code) @@ -814,14 +721,13 @@ def _check_previous_func_code(self, stacklevel=2): if self._verbose > 10: _, func_name = get_func_name(self.func, resolv_alias=False) self.warn("Function {0} (identified by {1}) has changed" - ".".format(func_name, func_id)) + ".".format(func_name, self.func_id)) self.clear(warn=True) return False def clear(self, warn=True): """Empty the function's cache.""" - func_id = _build_func_identifier(self.func) - + func_id = self.func_id if self._verbose > 0 and warn: self.warn("Clearing function cache identified by %s" % func_id) self.store_backend.clear_path([func_id, ]) @@ -846,27 +752,38 @@ def call(self, args, *kwargs): ------- output : object The output of the function call. - metadata : dict - The metadata associated with the call. """ + call_id = (self.func_id, self._get_args_id(args, *kwargs)) + return self._call(call_id, args, kwargs) + + def _call(self, call_id, args, kwargs, shelving=False): + self._before_call(args, kwargs) start_time = time.time() - func_id, args_id = self._get_output_identifiers(args, *kwargs) + output = self.func(args, *kwargs) + return self._after_call(call_id, args, kwargs, shelving, + output, start_time) + + def _before_call(self, args, kwargs): if self._verbose > 0: print(format_call(self.func, args, kwargs)) - output = self.func(args, *kwargs) - self.store_backend.dump_item( - [func_id, args_id], output, verbose=self._verbose) + def _after_call(self, call_id, args, kwargs, shelving, output, start_time): + self.store_backend.dump_item(call_id, output, verbose=self._verbose) duration = time.time() - start_time - metadata = self._persist_input(duration, args, kwargs) - if self._verbose > 0: - _, name = get_func_name(self.func) - msg = '%s - %s' % (name, format_time(duration)) - print(max(0, (80 - len(msg))) '_' + msg) - return output, metadata - - def _persist_input(self, duration, args, kwargs, this_duration_limit=0.5): + self._print_duration(duration) + metadata = self._persist_input(duration, call_id, args, kwargs) + if shelving: + return self._get_memorized_result(call_id, metadata) + + if self.mmap_mode is not None: + # Memmap the output at the first call to be consistent with + # later calls + output = self._load_item(call_id, metadata) + return output + + def _persist_input(self, duration, call_id, args, kwargs, + this_duration_limit=0.5): """ Save a small summary of the call using json format in the output directory. @@ -894,8 +811,7 @@ def _persist_input(self, duration, args, kwargs, this_duration_limit=0.5): "duration": duration, "input_args": input_repr, "time": start_time, } - func_id, args_id = self._get_output_identifiers(args, kwargs) - self.store_backend.store_metadata([func_id, args_id], metadata) + self.store_backend.store_metadata(call_id, metadata) this_duration = time.time() - start_time if this_duration > this_duration_limit: @@ -914,6 +830,21 @@ def _persist_input(self, duration, args, kwargs, this_duration_limit=0.5): % this_duration, stacklevel=5) return metadata + def _get_memorized_result(self, call_id, metadata=None): + return MemorizedResult(self.store_backend, call_id, + metadata=metadata, timestamp=self.timestamp, + verbose=self._verbose - 1) + + def _load_item(self, call_id, metadata=None): + return self.store_backend.load_item(call_id, metadata=metadata, + timestamp=self.timestamp, + verbose=self._verbose) + + def _print_duration(self, duration, context=''): + _, name = get_func_name(self.func) + msg = f"{name} {context}- {format_time(duration)}" + print(max(0, (80 - len(msg))) '_' + msg) + # ------------------------------------------------------------------------ # Private `object` interface # ------------------------------------------------------------------------ @@ -925,6 +856,30 @@ def __repr__(self): location=self.store_backend.location,) +############################################################################### +# class `AsyncMemorizedFunc` +############################################################################### +class AsyncMemorizedFunc(MemorizedFunc): + async def __call__(self, args, kwargs): + out = super().__call__(args, *kwargs) + return await out if asyncio.iscoroutine(out) else out + + async def call_and_shelve(self, args, *kwargs): + out = super().call_and_shelve(args, *kwargs) + return await out if asyncio.iscoroutine(out) else out + + async def call(self, args, *kwargs): + out = super().call(args, *kwargs) + return await out if asyncio.iscoroutine(out) else out + + async def _call(self, call_id, args, kwargs, shelving=False): + self._before_call(args, kwargs) + start_time = time.time() + output = await self.func(args, **kwargs) + return self._after_call(call_id, args, kwargs, shelving, + output, start_time) + + ############################################################################### # class `Memory` ############################################################################### @@ -1072,14 +1027,20 @@ def cache(self, func=None, ignore=None, verbose=None, mmap_mode=False, cache_validation_callback=cache_validation_callback ) if self.store_backend is None: - return NotMemorizedFunc(func) + cls = (AsyncNotMemorizedFunc + if asyncio.iscoroutinefunction(func) + else NotMemorizedFunc) + return cls(func) if verbose is None: verbose = self._verbose if mmap_mode is False: mmap_mode = self.mmap_mode if isinstance(func, MemorizedFunc): func = func.func - return MemorizedFunc( + cls = (AsyncMemorizedFunc + if asyncio.iscoroutinefunction(func) + else MemorizedFunc) + return cls( func, location=self.store_backend, backend=self.backend, ignore=ignore, mmap_mode=mmap_mode, compress=self.compress, verbose=verbose, timestamp=self.timestamp, @@ -1187,7 +1148,7 @@ def expires_after(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, days, seconds, microseconds, milliseconds, minutes, hours, weeks: numbers argument passed to a timedelta. """ - delta = timedelta( + delta = datetime.timedelta( days=days, seconds=seconds, microseconds=microseconds, milliseconds=milliseconds, minutes=minutes, hours=hours, weeks=weeks )	diff --git a/joblib/test/test_memory.py b/joblib/test/test_memory.py index ec9761fd1..120987b66 100644 --- a/joblib/test/test_memory.py +++ b/joblib/test/test_memory.py @@ -571,8 +571,8 @@ def test_func_dir(tmpdir): assert g._check_previous_func_code() # Test the robustness to failure of loading previous results. - func_id, args_id = g._get_output_identifiers(1) - output_dir = os.path.join(g.store_backend.location, func_id, args_id) + args_id = g._get_args_id(1) + output_dir = os.path.join(g.store_backend.location, g.func_id, args_id) a = g(1) assert os.path.exists(output_dir) os.remove(os.path.join(output_dir, 'output.pkl')) @@ -587,10 +587,10 @@ def test_persistence(tmpdir): h = pickle.loads(pickle.dumps(g)) - func_id, args_id = h._get_output_identifiers(1) - output_dir = os.path.join(h.store_backend.location, func_id, args_id) + args_id = h._get_args_id(1) + output_dir = os.path.join(h.store_backend.location, h.func_id, args_id) assert os.path.exists(output_dir) - assert output == h.store_backend.load_item([func_id, args_id]) + assert output == h.store_backend.load_item([h.func_id, args_id]) memory2 = pickle.loads(pickle.dumps(memory)) assert memory.store_backend.location == memory2.store_backend.location @@ -668,9 +668,9 @@ def test_call_and_shelve_lazily_load_stored_result(tmpdir): memory = Memory(location=tmpdir.strpath, verbose=0) func = memory.cache(f) - func_id, argument_hash = func._get_output_identifiers(2) + args_id = func._get_args_id(2) result_path = os.path.join(memory.store_backend.location, - func_id, argument_hash, 'output.pkl') + func.func_id, args_id, 'output.pkl') assert func(2) == 5 first_access_time = os.stat(result_path).st_atime time.sleep(1) @@ -875,7 +875,7 @@ def get_1000_bytes(arg): get_1000_bytes(arg) func_id = _build_func_identifier(get_1000_bytes) - hash_dirnames = [get_1000_bytes._get_output_identifiers(arg)[1] + hash_dirnames = [get_1000_bytes._get_args_id(arg) for arg in inputs] full_hashdirs = [os.path.join(get_1000_bytes.store_backend.location, diff --git a/joblib/test/test_memory_async.py b/joblib/test/test_memory_async.py new file mode 100644 index 000000000..ecad0c926 --- /dev/null +++ b/joblib/test/test_memory_async.py @@ -0,0 +1,149 @@ +import asyncio +import gc +import shutil + +import pytest + +from joblib.memory import (AsyncMemorizedFunc, AsyncNotMemorizedFunc, + MemorizedResult, Memory, NotMemorizedResult) +from joblib.test.common import np, with_numpy +from joblib.testing import raises + +from .test_memory import (corrupt_single_cache_item, + monkeypatch_cached_func_warn) + + +async def check_identity_lazy_async(func, accumulator, location): + """ Similar to check_identity_lazy_async for coroutine functions""" + memory = Memory(location=location, verbose=0) + func = memory.cache(func) + for i in range(3): + for _ in range(2): + value = await func(i) + assert value == i + assert len(accumulator) == i + 1 + + +@pytest.mark.asyncio +async def test_memory_integration_async(tmpdir): + accumulator = list() + + async def f(n): + await asyncio.sleep(0.1) + accumulator.append(1) + return n + + await check_identity_lazy_async(f, accumulator, tmpdir.strpath) + + # Now test clearing + for compress in (False, True): + for mmap_mode in ('r', None): + memory = Memory(location=tmpdir.strpath, verbose=10, + mmap_mode=mmap_mode, compress=compress) + # First clear the cache directory, to check that our code can + # handle that + # NOTE: this line would raise an exception, as the database + # file is still open; we ignore the error since we want to + # test what happens if the directory disappears + shutil.rmtree(tmpdir.strpath, ignore_errors=True) + g = memory.cache(f) + await g(1) + g.clear(warn=False) + current_accumulator = len(accumulator) + out = await g(1) + + assert len(accumulator) == current_accumulator + 1 + # Also, check that Memory.eval works similarly + evaled = await memory.eval(f, 1) + assert evaled == out + assert len(accumulator) == current_accumulator + 1 + + # Now do a smoke test with a function defined in __main__, as the name + # mangling rules are more complex + f.__module__ = '__main__' + memory = Memory(location=tmpdir.strpath, verbose=0) + await memory.cache(f)(1) + + +@pytest.mark.asyncio +async def test_no_memory_async(): + accumulator = list() + + async def ff(x): + await asyncio.sleep(0.1) + accumulator.append(1) + return x + + memory = Memory(location=None, verbose=0) + gg = memory.cache(ff) + for _ in range(4): + current_accumulator = len(accumulator) + await gg(1) + assert len(accumulator) == current_accumulator + 1 + + +@with_numpy +@pytest.mark.asyncio +async def test_memory_numpy_check_mmap_mode_async(tmpdir, monkeypatch): + """Check that mmap_mode is respected even at the first call""" + + memory = Memory(location=tmpdir.strpath, mmap_mode='r', verbose=0) + + @memory.cache() + async def twice(a): + return a * 2 + + a = np.ones(3) + b = await twice(a) + c = await twice(a) + + assert isinstance(c, np.memmap) + assert c.mode == 'r' + + assert isinstance(b, np.memmap) + assert b.mode == 'r' + + # Corrupts the file, Deleting b and c mmaps + # is necessary to be able edit the file + del b + del c + gc.collect() + corrupt_single_cache_item(memory) + + # Make sure that corrupting the file causes recomputation and that + # a warning is issued. + recorded_warnings = monkeypatch_cached_func_warn(twice, monkeypatch) + d = await twice(a) + assert len(recorded_warnings) == 1 + exception_msg = 'Exception while loading results' + assert exception_msg in recorded_warnings[0] + # Asserts that the recomputation returns a mmap + assert isinstance(d, np.memmap) + assert d.mode == 'r' + + +@pytest.mark.asyncio +async def test_call_and_shelve_async(tmpdir): + async def f(x, y=1): + await asyncio.sleep(0.1) + return x ** 2 + y + + # Test MemorizedFunc outputting a reference to cache. + for func, Result in zip((AsyncMemorizedFunc(f, tmpdir.strpath), + AsyncNotMemorizedFunc(f), + Memory(location=tmpdir.strpath, + verbose=0).cache(f), + Memory(location=None).cache(f), + ), + (MemorizedResult, NotMemorizedResult, + MemorizedResult, NotMemorizedResult, + )): + for _ in range(2): + result = await func.call_and_shelve(2) + assert isinstance(result, Result) + assert result.get() == 5 + + result.clear() + with raises(KeyError): + result.get() + result.clear() # Do nothing if there is no cache.	diff --git a/CHANGES.rst b/CHANGES.rst index 5bf9c956e..e191018d6 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -4,11 +4,14 @@ Latest changes In development -------------- +- Allow caching co-routines with `Memory.cache`. + https://github.com/joblib/joblib/pull/894 + - Try to cast ``n_jobs`` to int in parallel and raise an error if it fails. This means that ``n_jobs=2.3`` will now result in ``effective_n_jobs=2`` instead of failing. https://github.com/joblib/joblib/pull/1539 - + - Ensure that errors in the task generator given to Parallel's call are raised in the results consumming thread. https://github.com/joblib/joblib/pull/1491 diff --git a/continuous_integration/install.sh b/continuous_integration/install.sh index c6fed2883..9668b7474 100755 --- a/continuous_integration/install.sh +++ b/continuous_integration/install.sh @@ -34,7 +34,7 @@ else fi # Install pytest timeout to fasten failure in deadlocking tests -PIP_INSTALL_PACKAGES="pytest-timeout threadpoolctl" +PIP_INSTALL_PACKAGES="pytest-timeout pytest-asyncio==0.21.1 threadpoolctl" if [ -n "$NUMPY_VERSION" ]; then # We want to ensure no memory copies are performed only when numpy is	[ { "components": [ { "doc": "", "lines": [ 203, 204 ], "name": "MemorizedResult.func", "signature": "def func(self):", "type": "function" }, { "doc": "", "lines": [ 207, 208 ], ...	[ "joblib/test/test_memory.py::test_memory_integration", "joblib/test/test_memory.py::test_parallel_call_cached_function_defined_in_jupyter[True]", "joblib/test/test_memory.py::test_parallel_call_cached_function_defined_in_jupyter[False]", "joblib/test/test_memory.py::test_no_memory", "joblib/test/test_memory...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> ENH allow caching coroutine functions Addresses #889, allowing coroutine functions (available in Python 3.5+) to be decorated with `joblib.memory`. In short, the decorated function's `__call__` and `call_and_shelve` are coroutine functions that when `await`ed return the output or `MemorizedResult`, respectively, that would normally return if the original function was not a coroutine. A small subset of tests were ported from `test_memory` to their asyncio equivalent to verify the expected behavior. In order to keep the asyncio-specific implementation as small as possible, I had to refactor a large portion of `memory.py` first. It's a separate commit so it can be reviewed and tested independently. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in joblib/memory.py] (definition of MemorizedResult.func:) def func(self): (definition of MemorizedResult.func_id:) def func_id(self): (definition of MemorizedResult.args_id:) def args_id(self): (definition of AsyncNotMemorizedFunc:) class AsyncNotMemorizedFunc(NotMemorizedFunc): (definition of MemorizedFunc._get_args_id:) def _get_args_id(self, args, *kwargs): """Return the input parameter hash of a result.""" (definition of MemorizedFunc._call:) def _call(self, call_id, args, kwargs, shelving=False): (definition of MemorizedFunc._before_call:) def _before_call(self, args, kwargs): (definition of MemorizedFunc._after_call:) def _after_call(self, call_id, args, kwargs, shelving, output, start_time): (definition of MemorizedFunc._get_memorized_result:) def _get_memorized_result(self, call_id, metadata=None): (definition of MemorizedFunc._load_item:) def _load_item(self, call_id, metadata=None): (definition of MemorizedFunc._print_duration:) def _print_duration(self, duration, context=''): (definition of AsyncMemorizedFunc:) class AsyncMemorizedFunc(MemorizedFunc): [end of new definitions in joblib/memory.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		41b70ff10c293bd292465456434620e406d90d88
sympy__sympy-17030	17,030	sympy/sympy	1.5	a9751e4b979129ec399920e987569ca02bd9f3e4	2019-06-14T16:16:01Z	diff --git a/sympy/stats/rv.py b/sympy/stats/rv.py index 353a13974f9d..31ee14eb5ad7 100644 --- a/sympy/stats/rv.py +++ b/sympy/stats/rv.py @@ -280,7 +280,7 @@ def __new__(cls, idx_obj, pspace=None): return Basic.__new__(cls, idx_obj, pspace) symbol = property(lambda self: self.args[0]) - name = symbol + name = property(lambda self: str(self.args[0])) key = property(lambda self: self.symbol.args[1]) class ProductPSpace(PSpace): @@ -683,6 +683,9 @@ def expectation(expr, condition=None, numsamples=None, evaluate=True, kwargs): if numsamples: # Computing by monte carlo sampling? return sampling_E(expr, condition, numsamples=numsamples) + if expr.has(RandomIndexedSymbol): + return pspace(expr).compute_expectation(expr, condition, evaluate, kwargs) + # Create new expr and recompute E if condition is not None: # If there is a condition return expectation(given(expr, condition), evaluate=evaluate) @@ -737,7 +740,7 @@ def probability(condition, given_condition=None, numsamples=None, given_condition = sympify(given_condition) if condition.has(RandomIndexedSymbol): - return pspace(condition).probability(condition, given_condition, kwargs) + return pspace(condition).probability(condition, given_condition, evaluate, kwargs) if isinstance(given_condition, RandomSymbol): condrv = random_symbols(condition) diff --git a/sympy/stats/stochastic_process.py b/sympy/stats/stochastic_process.py index 4520830e1f31..5b012ec790e8 100644 --- a/sympy/stats/stochastic_process.py +++ b/sympy/stats/stochastic_process.py @@ -2,7 +2,7 @@ from sympy import Basic, Symbol from sympy.core.compatibility import string_types -from sympy.stats.rv import ProductDomain +from sympy.stats.rv import ProductDomain, _symbol_converter from sympy.stats.joint_rv import ProductPSpace, JointRandomSymbol class StochasticPSpace(ProductPSpace): @@ -11,19 +11,20 @@ class StochasticPSpace(ProductPSpace): and their random variables. Contains mechanics to do computations for queries of stochastic processes. - Initialized by symbol and the specific process. + Initialized by symbol, the specific process and + distribution(optional) if the random indexed symbols + of the process follows any specific distribution, like, + in Bernoulli Process, each random indexed symbol follows + Bernoulli distribution. For processes with memory, this + parameter should not be passed. """ - def __new__(cls, sym, process): - if isinstance(sym, string_types): - sym = Symbol(sym) - if not isinstance(sym, Symbol): - raise TypeError("Name of stochastic process should be either only " - "a string or Symbol.") + def __new__(cls, sym, process, distribution=None): + sym = _symbol_converter(sym) from sympy.stats.stochastic_process_types import StochasticProcess if not isinstance(process, StochasticProcess): raise TypeError("`process` must be an instance of StochasticProcess.") - return Basic.__new__(cls, sym, process) + return Basic.__new__(cls, sym, process, distribution) @property def process(self): @@ -41,37 +42,22 @@ def domain(self): def symbol(self): return self.args[0] - def probability(self, condition, given_condition=None, kwargs): + @property + def distribution(self): + return self.args[2] + + def probability(self, condition, given_condition=None, evaluate=True, kwargs): """ Transfers the task of handling queries to the specific stochastic process because every process has their own logic of handling such queries. """ - return self.process.probability(condition, given_condition, kwargs) + return self.process.probability(condition, given_condition, evaluate, kwargs) - def joint_distribution(self, args): + def compute_expectation(self, expr, condition=None, evaluate=True, kwargs): """ - Computes the joint distribution of the random indexed variables. - - Parameters - ========== - - args: iterable - The finite list of random indexed variables of a stochastic - process whose joint distribution has to be computed. - - Returns - ======= - - JointDistribution - The joint distribution of the list of random indexed variables. - An unevaluated object is returned if it is not possible to - compute the joint distribution. - - Raises - ====== - - ValueError: When the time/key of random indexed variables - is not in strictly increasing order. + Transfers the task of handling queries to the specific stochastic + process because every process has their own logic of handling such + queries. """ - NotImplementedError() + return self.process.expectation(expr, condition, evaluate, kwargs) diff --git a/sympy/stats/stochastic_process_types.py b/sympy/stats/stochastic_process_types.py index d6eefdc066fb..8f8d896266cd 100644 --- a/sympy/stats/stochastic_process_types.py +++ b/sympy/stats/stochastic_process_types.py @@ -1,11 +1,12 @@ from sympy import (Symbol, Matrix, MatrixSymbol, S, Indexed, Basic, Set, And, Tuple, Eq, FiniteSet, ImmutableMatrix, - nsimplify) + nsimplify, Lambda, Mul, Sum, Dummy, Lt) from sympy.stats.rv import (RandomIndexedSymbol, random_symbols, RandomSymbol, _symbol_converter) +from sympy.stats.joint_rv import JointDistributionHandmade, JointDistribution from sympy.core.compatibility import string_types from sympy.core.relational import Relational -from sympy.stats.symbolic_probability import Probability +from sympy.stats.symbolic_probability import Probability, Expectation from sympy.stats.stochastic_process import StochasticPSpace from sympy.logic.boolalg import Boolean @@ -71,7 +72,9 @@ class StochasticProcess(Basic): DiscreteTimeStochasticProcess """ - def __new__(cls, sym, state_space=S.Reals): + index_set = S.Reals + + def __new__(cls, sym, state_space=S.Reals, kwargs): sym = _symbol_converter(sym) state_space = _set_converter(state_space) return Basic.__new__(cls, sym, state_space) @@ -99,6 +102,53 @@ def __getitem__(self, time): def probability(self, condition): raise NotImplementedError() + def joint_distribution(self, args): + """ + Computes the joint distribution of the random indexed variables. + + Parameters + ========== + + args: iterable + The finite list of random indexed variables/the key of a stochastic + process whose joint distribution has to be computed. + + Returns + ======= + + JointDistribution + The joint distribution of the list of random indexed variables. + An unevaluated object is returned if it is not possible to + compute the joint distribution. + + Raises + ====== + + ValueError: When the arguments passed are not of type RandomIndexSymbol + or Number. + """ + args = list(args) + for i, arg in enumerate(args): + if S(arg).is_Number: + if self.index_set.is_subset(S.Integers): + args[i] = self.__getitem__(arg) + else: + args[i] = self.__call__(arg) + elif not isinstance(arg, RandomIndexedSymbol): + raise ValueError("Expected a RandomIndexedSymbol or " + "key not %s"%(type(arg))) + + if args[0].pspace.distribution == None: # checks if there is any distribution available + return JointDistribution(args) + # TODO: Add tests for the below part of the method, when implementation of Bernoulli Process + # is completed + pdf = Lambda([arg.name for arg in args], + expr=Mul.fromiter(arg.pspace.distribution.pdf(arg) for arg in args)) + return JointDistributionHandmade(pdf) + + def expectation(self, condition, given_condition): + raise NotImplementedError("Abstract method for expectation queries.") + class DiscreteTimeStochasticProcess(StochasticProcess): """ Base class for all discrete stochastic processes. @@ -182,6 +232,8 @@ class DiscreteMarkovChain(DiscreteTimeStochasticProcess): 0.36 """ + is_markov = True + index_set = S.Naturals0 def __new__(cls, sym, state_space=S.Reals, trans_probs=None): @@ -199,36 +251,11 @@ def transition_probabilities(self): """ return self.args[2] - def probability(self, condition, given_condition, kwargs): + def _extract_information(self, given_condition): """ - Handles probability queries for discrete Markov chains. - - Parameters - ========== - - condition: Relational - given_condition: Relational/And - - Returns - ======= - - Probability - If the transition probabilities are not available - Expr - If the transition probabilities is MatrixSymbol or Matrix - - Note - ==== - - Any information passed at the time of query overrides - any information passed at the time of object creation like - transition probabilities, state space. - - Pass the transition matrix using TransitionMatrixOf and state space - using StochasticStateSpaceOf in given_condition using & or And. + Helper function to extract information, like, + transition probabilities, state space, etc. """ - - # extracting transition matrix and state space trans_probs, state_space = self.transition_probabilities, self.state_space if isinstance(given_condition, And): gcs = given_condition.args @@ -243,14 +270,13 @@ def probability(self, condition, given_condition, kwargs): trans_probs = given_condition.matrix if isinstance(given_condition, StochasticStateSpaceOf): state_space = given_condition.state_space + return trans_probs, state_space, given_condition - # given_condition does not have sufficient information - # for computations - if trans_probs == None or \ - given_condition == None: - return Probability(condition, given_condition, kwargs) - - # working out transition probabilities + def _check_trans_probs(self, trans_probs): + """ + Helper function for checking the validity of transition + probabilities. + """ if not isinstance(trans_probs, MatrixSymbol): rows = trans_probs.tolist() for row in rows: @@ -258,6 +284,11 @@ def probability(self, condition, given_condition, kwargs): raise ValueError("Probabilities in a row must sum to 1. " "If you are using Float or floats then please use Rational.") + def _work_out_state_space(self, state_space, given_condition, trans_probs): + """ + Helper function to extract state space if there + is a random symbol in the given condition. + """ # if given condition is None, then there is no need to work out # state_space from random variables if given_condition != None: @@ -267,6 +298,68 @@ def probability(self, condition, given_condition, *kwargs): state_space = rand_var[0].pspace.set if not FiniteSet([i for i in range(trans_probs.shape[0])]).is_subset(state_space): raise ValueError("state space is not compatible with the transition probabilites.") + return state_space + + def _preprocess(self, given_condition, evaluate): + """ + Helper function for pre-processing the information. + """ + is_insufficient = False + + if not evaluate: # avoid pre-processing if the result is not to be evaluated + return (True, None, None, None) + + # extracting transition matrix and state space + trans_probs, state_space, given_condition = self._extract_information(given_condition) + + # given_condition does not have sufficient information + # for computations + if trans_probs == None or \ + given_condition == None: + is_insufficient = True + else: + # checking transition probabilities + self._check_trans_probs(trans_probs) + + # working out state space + state_space = self._work_out_state_space(state_space, given_condition, trans_probs) + + return is_insufficient, trans_probs, state_space, given_condition + + def probability(self, condition, given_condition=None, evaluate=True, kwargs): + """ + Handles probability queries for discrete Markov chains. + + Parameters + ========== + + condition: Relational + given_condition: Relational/And + + Returns + ======= + + Probability + If the transition probabilities are not available + Expr + If the transition probabilities is MatrixSymbol or Matrix + + Note + ==== + + Any information passed at the time of query overrides + any information passed at the time of object creation like + transition probabilities, state space. + + Pass the transition matrix using TransitionMatrixOf and state space + using StochasticStateSpaceOf in given_condition using & or And. + """ + + check, trans_probs, state_space, given_condition = \ + self._preprocess(given_condition, evaluate) + + if check: + return Probability(condition, given_condition) if isinstance(condition, Eq) and \ isinstance(given_condition, Eq) and \ @@ -279,7 +372,7 @@ def probability(self, condition, given_condition, kwargs): if not isinstance(lhsg, RandomIndexedSymbol): lhsg, rhsg = (rhsg, lhsg) keyc, statec, keyg, stateg = (lhsc.key, rhsc, lhsg.key, rhsg) - if stateg >= trans_probs.shape[0] == False or statec >= trans_probs.shape[1]: + if Lt(stateg, trans_probs.shape[0]) == False or Lt(statec, trans_probs.shape[1]) == False: raise IndexError("No information is avaliable for (%s, %s) in " "transition probabilities of shape, (%s, %s). " "State space is zero indexed." @@ -312,3 +405,62 @@ def probability(self, condition, given_condition, kwargs): raise NotImplementedError("Mechanism for handling (%s, %s) queries hasn't been " "implemented yet."%(condition, given_condition)) + + def expectation(self, expr, condition=None, evaluate=True, kwargs): + """ + Handles expectation queries for discrete markov chains. + + Parameters + ========== + + expr: RandomIndexedSymbol, Relational, Logic + Condition for which expectation has to be computed. Must + contain a RandomIndexedSymbol of the process. + condition: Relational, Logic + The given conditions under which computations should be done. + + Returns + ======= + + Expectation + Unevaluated object if computations cannot be done due to + insufficient information. + Expr + In all other cases when the computations are successfull. + + Note + ==== + + Any information passed at the time of query overrides + any information passed at the time of object creation like + transition probabilities, state space. + + Pass the transition matrix using TransitionMatrixOf and state space + using StochasticStateSpaceOf in given_condition using & or And. + """ + + check, trans_probs, state_space, condition = \ + self._preprocess(condition, evaluate) + + if check: + return Expectation(expr, condition) + + if isinstance(expr, RandomIndexedSymbol): + if isinstance(condition, Eq): + # handle queries similar to E(X[i], Eq(X[i-m], <some-state>)) + lhsg, rhsg = condition.lhs, condition.rhs + if not isinstance(lhsg, RandomIndexedSymbol): + lhsg, rhsg = (rhsg, lhsg) + if rhsg not in self.state_space: + raise ValueError("%s state is not in the state space."%(rhsg)) + if expr.key < lhsg.key: + raise ValueError("Incorrect given condition is given, expectation " + "time %s < time %s"%(expr.key, lhsg.key)) + cond = condition & TransitionMatrixOf(self, trans_probs) & \ + StochasticStateSpaceOf(self, state_space) + s = Dummy('s') + func = Lambda(s, self.probability(Eq(expr, s), cond)*s) + return Sum(func(s), (s, state_space.inf, state_space.sup)).doit() + + raise NotImplementedError("Mechanism for handling (%s, %s) queries hasn't been " + "implemented yet."%(expr, condition))	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 44b4bd07b751..8781cdc48a6d 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1551,7 +1551,8 @@ def test_sympy__stats__rv__RandomIndexedSymbol(): def test_sympy__stats__stochastic_process__StochasticPSpace(): from sympy.stats.stochastic_process import StochasticPSpace from sympy.stats.stochastic_process_types import StochasticProcess - assert _test_args(StochasticPSpace("Y", StochasticProcess("Y", [1, 2, 3]))) + from sympy.stats.frv_types import BernoulliDistribution + assert _test_args(StochasticPSpace("Y", StochasticProcess("Y", [1, 2, 3]), BernoulliDistribution(S(1)/2, 1, 0))) def test_sympy__stats__stochastic_process_types__StochasticProcess(): from sympy.stats.stochastic_process_types import StochasticProcess diff --git a/sympy/stats/tests/test_stochastic_process.py b/sympy/stats/tests/test_stochastic_process.py index cd974e42afb0..3f459ebf9cb9 100644 --- a/sympy/stats/tests/test_stochastic_process.py +++ b/sympy/stats/tests/test_stochastic_process.py @@ -1,7 +1,8 @@ from sympy import (S, symbols, FiniteSet, Eq, Matrix, MatrixSymbol, Float, And) -from sympy.stats import DiscreteMarkovChain, P, TransitionMatrixOf +from sympy.stats import DiscreteMarkovChain, P, TransitionMatrixOf, E from sympy.stats.rv import RandomIndexedSymbol -from sympy.stats.symbolic_probability import Probability +from sympy.stats.symbolic_probability import Probability, Expectation +from sympy.stats.joint_rv import JointDistribution from sympy.utilities.pytest import raises def test_DiscreteMarkovChain(): @@ -13,25 +14,41 @@ def test_DiscreteMarkovChain(): assert X.transition_probabilities == None t = symbols('t', positive=True, integer=True) assert isinstance(X[t], RandomIndexedSymbol) + assert E(X[0]) == Expectation(X[0]) + raises(TypeError, lambda: DiscreteMarkovChain(1)) + raises(NotImplementedError, lambda: X(t)) # pass name and state_space Y = DiscreteMarkovChain("Y", [1, 2, 3]) assert Y.transition_probabilities == None assert Y.state_space == FiniteSet(1, 2, 3) assert P(Eq(Y[2], 1), Eq(Y[0], 2)) == Probability(Eq(Y[2], 1), Eq(Y[0], 2)) + assert E(X[0]) == Expectation(X[0]) + raises(TypeError, lambda: DiscreteMarkovChain("Y", dict((1, 1)))) # pass name, state_space and transition_probabilities T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]]) TS = MatrixSymbol('T', 3, 3) Y = DiscreteMarkovChain("Y", [0, 1, 2], T) YS = DiscreteMarkovChain("Y", [0, 1, 2], TS) + assert Y.joint_distribution(1, Y[2], 3) == JointDistribution(Y[1], Y[2], Y[3]) + raises(ValueError, lambda: Y.joint_distribution(Y[1].symbol, Y[2].symbol)) assert P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) == Float(0.36, 2) assert str(P(Eq(YS[3], 2), Eq(YS[1], 1))) == \ "T[0, 2]T[1, 0] + T[1, 1]T[1, 2] + T[1, 2]*T[2, 2]" TO = Matrix([[0.25, 0.75, 0],[0, 0.25, 0.75],[0.75, 0, 0.25]]) assert P(Eq(Y[3], 2), Eq(Y[1], 1) & TransitionMatrixOf(Y, TO)).round(3) == Float(0.375, 3) + assert E(Y[3], evaluate=False) == Expectation(Y[3]) + assert E(Y[3], Eq(Y[2], 1)).round(2) == Float(1.1, 3) TSO = MatrixSymbol('T', 4, 4) raises(ValueError, lambda: str(P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TSO)))) + raises(TypeError, lambda: DiscreteMarkovChain("Z", [0, 1, 2], symbols('M'))) + raises(ValueError, lambda: DiscreteMarkovChain("Z", [0, 1, 2], MatrixSymbol('T', 3, 4))) + raises(IndexError, lambda: str(P(Eq(YS[3], 3), Eq(YS[1], 1)))) + raises(ValueError, lambda: str(P(Eq(YS[1], 1), Eq(YS[2], 2)))) + raises(ValueError, lambda: E(Y[3], Eq(Y[2], 6))) + raises(ValueError, lambda: E(Y[2], Eq(Y[3], 1))) + # extended tests for probability queries TO1 = Matrix([[S(1)/4, S(3)/4, 0],[S(1)/3, S(1)/3, S(1)/3],[0, S(1)/4, S(3)/4]]) @@ -39,3 +56,4 @@ def test_DiscreteMarkovChain(): Eq(Probability(Eq(Y[0], 0)), S(1)/4) & TransitionMatrixOf(Y, TO1)) == S(1)/16 assert P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)), TransitionMatrixOf(Y, TO1)) == \ Probability(Eq(Y[0], 0))/4 + raises (ValueError, lambda: str(P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)), Eq(Y[1], 1))))		[ { "components": [ { "doc": "", "lines": [ 46, 47 ], "name": "StochasticPSpace.distribution", "signature": "def distribution(self):", "type": "function" }, { "doc": "Transfers the task of handling queries to the specifi...	[ "test_sympy__stats__stochastic_process__StochasticPSpace" ]	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Adding more features to StochasticProcess <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> [1] https://github.com/sympy/sympy/pull/16981 #### Brief description of what is fixed or changed `joint_dsitribution` has been added to `StochasticProcess`. Test coverage has also been increased. #### Other comments More features like, `compute_expectation` will be added to the `StochasticProcess`. Provide your suggestions in the comments, if something more can be added. :) #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * stats * `joint_distribution` added to `StochasticProcess`. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/stochastic_process.py] (definition of StochasticPSpace.distribution:) def distribution(self): (definition of StochasticPSpace.compute_expectation:) def compute_expectation(self, expr, condition=None, evaluate=True, *kwargs): """Transfers the task of handling queries to the specific stochastic process because every process has their own logic of handling such queries.""" [end of new definitions in sympy/stats/stochastic_process.py] [start of new definitions in sympy/stats/stochastic_process_types.py] (definition of StochasticProcess.joint_distribution:) def joint_distribution(self, args): """Computes the joint distribution of the random indexed variables. Parameters ========== args: iterable The finite list of random indexed variables/the key of a stochastic process whose joint distribution has to be computed. Returns ======= JointDistribution The joint distribution of the list of random indexed variables. An unevaluated object is returned if it is not possible to compute the joint distribution. Raises ====== ValueError: When the arguments passed are not of type RandomIndexSymbol or Number.""" (definition of StochasticProcess.expectation:) def expectation(self, condition, given_condition): (definition of DiscreteMarkovChain._extract_information:) def _extract_information(self, given_condition): """Helper function to extract information, like, transition probabilities, state space, etc.""" (definition of DiscreteMarkovChain._check_trans_probs:) def _check_trans_probs(self, trans_probs): """Helper function for checking the validity of transition probabilities.""" (definition of DiscreteMarkovChain._work_out_state_space:) def _work_out_state_space(self, state_space, given_condition, trans_probs): """Helper function to extract state space if there is a random symbol in the given condition.""" (definition of DiscreteMarkovChain._preprocess:) def _preprocess(self, given_condition, evaluate): """Helper function for pre-processing the information.""" (definition of DiscreteMarkovChain.expectation:) def expectation(self, expr, condition=None, evaluate=True, **kwargs): """Handles expectation queries for discrete markov chains. Parameters ========== expr: RandomIndexedSymbol, Relational, Logic Condition for which expectation has to be computed. Must contain a RandomIndexedSymbol of the process. condition: Relational, Logic The given conditions under which computations should be done. Returns ======= Expectation Unevaluated object if computations cannot be done due to insufficient information. Expr In all other cases when the computations are successfull. Note ==== Any information passed at the time of query overrides any information passed at the time of object creation like transition probabilities, state space. Pass the transition matrix using TransitionMatrixOf and state space using StochasticStateSpaceOf in given_condition using & or And.""" [end of new definitions in sympy/stats/stochastic_process_types.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-17019	17,019	sympy/sympy	1.5	3febfc43ca0aa23d916ef06057e8c6d396a955e7	2019-06-12T16:45:32Z	diff --git a/sympy/assumptions/refine.py b/sympy/assumptions/refine.py index 0ed132bee5ae..52099d71abe7 100644 --- a/sympy/assumptions/refine.py +++ b/sympy/assumptions/refine.py @@ -240,6 +240,57 @@ def refine_Relational(expr, assumptions): return ask(Q.is_true(expr), assumptions) +def refine_re(expr, assumptions): + """ + Handler for real part. + + >>> from sympy.assumptions.refine import refine_re + >>> from sympy import Q, re + >>> from sympy.abc import x + >>> refine_re(re(x), Q.real(x)) + x + >>> refine_re(re(x), Q.imaginary(x)) + 0 + """ + arg = expr.args[0] + if ask(Q.real(arg), assumptions): + return arg + if ask(Q.imaginary(arg), assumptions): + return 0 + return _refine_reim(expr, assumptions) + + +def refine_im(expr, assumptions): + """ + Handler for imaginary part. + + >>> from sympy.assumptions.refine import refine_im + >>> from sympy import Q, im + >>> from sympy.abc import x + >>> refine_im(im(x), Q.real(x)) + 0 + >>> refine_im(im(x), Q.imaginary(x)) + -Ix + """ + arg = expr.args[0] + if ask(Q.real(arg), assumptions): + return 0 + if ask(Q.imaginary(arg), assumptions): + return - S.ImaginaryUnit arg + return _refine_reim(expr, assumptions) + + +def _refine_reim(expr, assumptions): + # Helper function for refine_re & refine_im + expanded = expr.expand(complex = True) + if expanded != expr: + refined = refine(expanded, assumptions) + if refined != expanded: + return refined + # Best to leave the expression as is + return None + + handlers_dict = { 'Abs': refine_abs, 'Pow': refine_Pow, @@ -249,5 +300,7 @@ def refine_Relational(expr, assumptions): 'GreaterThan': refine_Relational, 'LessThan': refine_Relational, 'StrictGreaterThan': refine_Relational, - 'StrictLessThan': refine_Relational + 'StrictLessThan': refine_Relational, + 're': refine_re, + 'im': refine_im }	diff --git a/sympy/assumptions/tests/test_refine.py b/sympy/assumptions/tests/test_refine.py index 0fd1ef8031af..15f9878c37d9 100644 --- a/sympy/assumptions/tests/test_refine.py +++ b/sympy/assumptions/tests/test_refine.py @@ -1,6 +1,6 @@ from sympy import (Abs, exp, Expr, I, pi, Q, Rational, refine, S, sqrt, - atan, atan2, nan, Symbol) -from sympy.abc import x, y, z + atan, atan2, nan, Symbol, re, im) +from sympy.abc import w, x, y, z from sympy.core.relational import Eq, Ne from sympy.functions.elementary.piecewise import Piecewise from sympy.utilities.pytest import slow @@ -145,6 +145,39 @@ def test_atan2(): assert refine(atan2(y, x), Q.zero(y) & Q.zero(x)) == nan +def test_re(): + assert refine(re(x), Q.real(x)) == x + assert refine(re(x), Q.imaginary(x)) == 0 + assert refine(re(x+y), Q.real(x) & Q.real(y)) == x + y + assert refine(re(x+y), Q.real(x) & Q.imaginary(y)) == x + assert refine(re(xy), Q.real(x) & Q.real(y)) == x y + assert refine(re(xy), Q.real(x) & Q.imaginary(y)) == 0 + assert refine(re(xyz), Q.real(x) & Q.real(y) & Q.real(z)) == x y * z + + +def test_im(): + assert refine(im(x), Q.imaginary(x)) == -Ix + assert refine(im(x), Q.real(x)) == 0 + assert refine(im(x+y), Q.imaginary(x) & Q.imaginary(y)) == -Ix - Iy + assert refine(im(x+y), Q.real(x) & Q.imaginary(y)) == -Iy + assert refine(im(xy), Q.imaginary(x) & Q.real(y)) == -Ixy + assert refine(im(xy), Q.imaginary(x) & Q.imaginary(y)) == 0 + assert refine(im(1/x), Q.imaginary(x)) == -I/x + assert refine(im(xyz), Q.imaginary(x) & Q.imaginary(y) + & Q.imaginary(z)) == -Ixyz + + +def test_complex(): + assert refine(re(1/(x + Iy)), Q.real(x) & Q.real(y)) == \ + x/(x2 + y2) + assert refine(im(1/(x + Iy)), Q.real(x) & Q.real(y)) == \ + -y/(x2 + y2) + assert refine(re((w + Ix) * (y + Iz)), Q.real(w) & Q.real(x) & Q.real(y) + & Q.real(z)) == wy - xz + assert refine(im((w + Ix) * (y + Iz)), Q.real(w) & Q.real(x) & Q.real(y) + & Q.real(z)) == wz + x*y + + def test_func_args(): class MyClass(Expr): # A class with nontrivial .func		[ { "components": [ { "doc": "Handler for real part.\n\n>>> from sympy.assumptions.refine import refine_re\n>>> from sympy import Q, re\n>>> from sympy.abc import x\n>>> refine_re(re(x), Q.real(x))\nx\n>>> refine_re(re(x), Q.imaginary(x))\n0", "lines": [ 243, 260 ...	[ "test_re", "test_im", "test_complex" ]	[ "test_Abs", "test_pow1", "test_exp", "test_Relational", "test_Piecewise", "test_atan2", "test_func_args", "test_eval_refine" ]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add refine handlers for re(), im(). <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> Issue #17011 #### Brief description of what is fixed or changed Added two methods ``` refine_re() ``` & ``` refine_im() ``` in ``` sympy.assumptions.refine.py ``` along with tests. #### Other comments I wasn't sure how to handle cases where there wasn't enough information about the variables. With the current changes, ``` refine(re(xy)) ``` gives ``` re(x)re(y) - im(x)im(y) ``` which might actually be less preferable than ``` re(xy) ```. #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * assumptions * add refine_re() , refine_im() <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/assumptions/refine.py] (definition of refine_re:) def refine_re(expr, assumptions): """Handler for real part. >>> from sympy.assumptions.refine import refine_re >>> from sympy import Q, re >>> from sympy.abc import x >>> refine_re(re(x), Q.real(x)) x >>> refine_re(re(x), Q.imaginary(x)) 0""" (definition of refine_im:) def refine_im(expr, assumptions): """Handler for imaginary part. >>> from sympy.assumptions.refine import refine_im >>> from sympy import Q, im >>> from sympy.abc import x >>> refine_im(im(x), Q.real(x)) 0 >>> refine_im(im(x), Q.imaginary(x)) -I*x""" (definition of _refine_reim:) def _refine_reim(expr, assumptions): [end of new definitions in sympy/assumptions/refine.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-16991	16,991	sympy/sympy	1.5	8f4999d744827bc6b29e05e8ec4e6bc1bf8a5d11	2019-06-08T12:04:27Z	diff --git a/doc/src/modules/combinatorics/index.rst b/doc/src/modules/combinatorics/index.rst index f753a41ae16a..2d70a46a13ee 100644 --- a/doc/src/modules/combinatorics/index.rst +++ b/doc/src/modules/combinatorics/index.rst @@ -23,3 +23,4 @@ Contents testutil.rst tensor_can.rst fp_groups.rst + pc_groups.rst diff --git a/doc/src/modules/combinatorics/pc_groups.rst b/doc/src/modules/combinatorics/pc_groups.rst new file mode 100644 index 000000000000..4114bbebebfd --- /dev/null +++ b/doc/src/modules/combinatorics/pc_groups.rst @@ -0,0 +1,12 @@ +.. _combinatorics-pc_groups: + +Polycyclic Groups +================= + +.. module:: sympy.combinatorics.pc_groups + +.. autoclass:: PolycyclicGroup + :members: + +.. autoclass:: Collector + :members: \ No newline at end of file diff --git a/sympy/combinatorics/__init__.py b/sympy/combinatorics/__init__.py index dae9c62de88d..c620fb1b38fa 100644 --- a/sympy/combinatorics/__init__.py +++ b/sympy/combinatorics/__init__.py @@ -11,3 +11,4 @@ from sympy.combinatorics.graycode import GrayCode from sympy.combinatorics.named_groups import (SymmetricGroup, DihedralGroup, CyclicGroup, AlternatingGroup, AbelianGroup, RubikGroup) +from sympy.combinatorics.pc_groups import PolycyclicGroup, Collector diff --git a/sympy/combinatorics/pc_groups.py b/sympy/combinatorics/pc_groups.py new file mode 100644 index 000000000000..25507b375fa8 --- /dev/null +++ b/sympy/combinatorics/pc_groups.py @@ -0,0 +1,490 @@ +from sympy.core import Basic +from sympy import isprime, symbols +from sympy.combinatorics.perm_groups import PermutationGroup +from sympy.printing.defaults import DefaultPrinting +from sympy.combinatorics.free_groups import free_group + +class PolycyclicGroup(DefaultPrinting): + + is_group = True + is_solvable = True + + def __init__(self, pc_sequence, pc_series, relative_order, collector=None): + self.pcgs = pc_sequence + self.pc_series = pc_series + self.relative_order = relative_order + self.collector = Collector(self.pcgs, pc_series, relative_order) if not collector else collector + + def is_prime_order(self): + return all(isprime(order) for order in self.relative_order) + + def length(self): + return len(self.pcgs) + + +class Collector(DefaultPrinting): + + """ + References + ========== + + .. [1] Holt, D., Eick, B., O'Brien, E. + "Handbook of Computational Group Theory" + Section 8.1.3 + """ + + def __init__(self, pcgs, pc_series, relative_order, group=None, pc_presentation=None): + self.pcgs = pcgs + self.pc_series = pc_series + self.relative_order = relative_order + self.free_group = free_group('x:{0}'.format(len(pcgs)))[0] if not group else group + self.index = {s: i for i, s in enumerate(self.free_group.symbols)} + self.pc_presentation = self.pc_relators() + + def minimal_uncollected_subword(self, word): + """ + Returns the minimal uncollected subwords. + + A word `v` defined on generators in `X` is a minimal + uncollected subword of the word `w` if `v` is a subword + of `w` and it has one of the following form + + i) `v = x[i+1]*a_jx[i]` + + ii) `v = x[i+1]*a_jx[i]-1` + + iii) `v = x[i]a_j` for relative_order of `x[i] != infinity` + and `a_j` is not in `{1, ..., s-1}`. Where, s is the power + exponent of the corresponding generator. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> from sympy.combinatorics.free_groups import free_group + >>> G = SymmetricGroup(4) + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> F, x1, x2 = free_group("x1, x2") + >>> word = x2*2x17 + >>> collector.minimal_uncollected_subword(word) + ((x2, 2),) + + """ + # To handle the case word = <identity> + if not word: + return None + + array = word.array_form + re = self.relative_order + index = self.index + + for i in range(len(array)): + s1, e1 = array[i] + + if re[index[s1]] and (e1 < 0 or e1 > re[index[s1]]-1): + return ((s1, e1), ) + + for i in range(len(array)-1): + s1, e1 = array[i] + s2, e2 = array[i+1] + + if index[s1] > index[s2]: + e = 1 if e2 > 0 else -1 + return ((s1, e1), (s2, e)) + + return None + + def relations(self): + """ + Separates the given relators of pc presentation in power and + conjugate relations. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> G = SymmetricGroup(3) + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> power_rel, conj_rel = collector.relations() + >>> power_rel + {x02: (), x13: ()} + >>> conj_rel + {x0-1x1x0: x12} + + """ + power_relators = {} + conjugate_relators = {} + for key, value in self.pc_presentation.items(): + if len(key.array_form) == 1: + power_relators[key] = value + else: + conjugate_relators[key] = value + return power_relators, conjugate_relators + + def subword_index(self, word, w): + """ + Returns the start and ending index of a given + subword in a word. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> from sympy.combinatorics.free_groups import free_group + >>> G = SymmetricGroup(4) + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> F, x1, x2 = free_group("x1, x2") + >>> word = x22x17 + >>> w = x22x1 + >>> collector.subword_index(word, w) + (0, 3) + >>> w = x1*7 + >>> collector.subword_index(word, w) + (2, 9) + + """ + low = -1 + high = -1 + for i in range(len(word)-len(w)+1): + if word.subword(i, i+len(w)) == w: + low = i + high = i+len(w) + break + if low == high == -1: + return -1, -1 + return low, high + + def map_relation(self, w): + """ + Return a conjugate relation. + Given a word formed by two free group elements, the + corresponding conjugate relation with those free + group elements is formed and mapped with the collected + word in the polycyclic presentation. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> from sympy.combinatorics.free_groups import free_group + >>> G = SymmetricGroup(3) + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> F, x0, x1 = free_group("x0, x1") + >>> w = x1x0 + >>> collector.map_relation(w) + x12 + + """ + array = w.array_form + s1 = array[0][0] + s2 = array[1][0] + key = ((s2, -1), (s1, 1), (s2, 1)) + key = self.free_group.dtype(key) + return self.pc_presentation[key] + + + def collected_word(self, word): + """ + Return the collected form of a word. + + A word `w` is called collected, if `w = x{i_1}a_1...x{i_r}*a_r` + with `i_1 < i_2< ... < i_r` and `a_j` is in `{1, ..., s_j-1}` + if `s_j != infinity`. + Otherwise w is uncollected. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> from sympy.combinatorics.perm_groups import PermutationGroup + >>> from sympy.combinatorics.free_groups import free_group + >>> G = SymmetricGroup(4) + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> F, x0, x1, x2, x3 = free_group("x0, x1, x2, x3") + >>> word = x3x2x1x0 + >>> collected_word = collector.collected_word(word) + >>> free_to_perm = {} + >>> free_group = collector.free_group + >>> for sym, gen in zip(free_group.symbols, collector.pcgs): + ... free_to_perm[sym] = gen + >>> G1 = PermutationGroup() + >>> for w in word: + ... sym = w[0] + ... perm = free_to_perm[sym] + ... G1 = PermutationGroup([perm] + G1.generators) + >>> G2 = PermutationGroup() + >>> for w in collected_word: + ... sym = w[0] + ... perm = free_to_perm[sym] + ... G2 = PermutationGroup([perm] + G2.generators) + >>> G1 == G2 + True + + """ + free_group = self.free_group + while True: + w = self.minimal_uncollected_subword(word) + if not w: + break + + low, high = self.subword_index(word, free_group.dtype(w)) + if low == -1: + continue + + s1, e1 = w[0] + if len(w) == 1: + re = self.relative_order[self.index[s1]] + q = e1 // re + r = e1-qre + + key = ((w[0][0], re), ) + key = free_group.dtype(key) + if self.pc_presentation[key]: + word_ = ((w[0][0], r), (self.pc_presentation[key], q)) + word_ = free_group.dtype(word_) + else: + if r != 0: + word_ = ((w[0][0], r), ) + word_ = free_group.dtype(word_) + else: + word_ = None + word = word.eliminate_word(free_group.dtype(w), word_) + + if len(w) == 2 and w[1][1] > 0: + s2, e2 = w[1] + s2 = ((s2, 1), ) + s2 = free_group.dtype(s2) + word_ = self.map_relation(free_group.dtype(w)) + word_ = s2word_e1 + word_ = free_group.dtype(word_) + word = word.substituted_word(low, high, word_) + + elif len(w) == 2 and w[1][1] < 0: + s2, e2 = w[1] + s2 = ((s2, 1), ) + s2 = free_group.dtype(s2) + word_ = self.map_relation(free_group.dtype(w)) + word_ = s2-1word_e1 + word_ = free_group.dtype(word_) + word = word.substituted_word(low, high, word_) + + return word + + + def pc_relators(self): + """ + Return the polycyclic presentation. + + There are two types of relations used in polycyclic + presentation. + i) Power relations of the form `x{i}^re{i} = R{i}{i}`, + `for 0 <= i < length(pcgs)` where `x` represents polycyclic + generator and `re` is the corresponding relative order. + + ii) Conjugate relations of the form `x{j}^-1x{i}x{j}`, + `for 0 <= j < i <= length(pcgs)`. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> from sympy.combinatorics.permutations import Permutation + >>> S = SymmetricGroup(49).sylow_subgroup(7) + >>> der = S.derived_series() + >>> G = der[len(der)-2] + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> pcgs = PcGroup.pcgs + >>> len(pcgs) + 6 + >>> free_group = collector.free_group + >>> pc_resentation = collector.pc_presentation + >>> free_to_perm = {} + >>> for s, g in zip(free_group.symbols, pcgs): + ... free_to_perm[s] = g + + >>> for k, v in pc_resentation.items(): + ... k_array = k.array_form + ... if v != (): + ... v_array = v.array_form + ... lhs = Permutation() + ... for gen in k_array: + ... s = gen[0] + ... e = gen[1] + ... lhs = lhsfree_to_perm[s]*e + ... if v == (): + ... assert lhs.is_identity + ... continue + ... rhs = Permutation() + ... for gen in v_array: + ... s = gen[0] + ... e = gen[1] + ... rhs = rhsfree_to_perm[s]e + ... assert lhs == rhs + + """ + free_group = self.free_group + rel_order = self.relative_order + pc_relators = {} + perm_to_free = {} + pcgs = self.pcgs + + for gen, s in zip(pcgs, free_group.generators): + perm_to_free[gen-1] = s-1 + perm_to_free[gen] = s + + pcgs = pcgs[::-1] + series = self.pc_series[::-1] + rel_order = rel_order[::-1] + collected_gens = [] + + for i, gen in enumerate(pcgs): + re = rel_order[i] + relation = perm_to_free[gen]re + G = series[i] + + l = G.generator_product(gen*re, original = True) + l.reverse() + + word = free_group.identity + for g in l: + word = wordperm_to_free[g] + + word = self.collected_word(word) + pc_relators[relation] = word if word else () + self.pc_presentation = pc_relators + + collected_gens.append(gen) + if len(collected_gens) > 1: + conj = collected_gens[len(collected_gens)-1] + conjugator = perm_to_free[conj] + + for j in range(len(collected_gens)-1): + conjugated = perm_to_free[collected_gens[j]] + + relation = conjugator*-1conjugatedconjugator + gens = conj-1collected_gens[j]conj + + l = G.generator_product(gens, original = True) + l.reverse() + word = free_group.identity + for g in l: + word = wordperm_to_free[g] + + word = self.collected_word(word) + pc_relators[relation] = word if word else () + self.pc_presentation = pc_relators + + return pc_relators + + def exponent_vector(self, element): + """ + Return the exponent vector of length equal to the + length of polycyclic generating sequence. + + For a given generator/element `g` of the polycyclic group, + it can be represented as `g = x{1}e{1}....x{n}e{n}`, + where `x{i}` represents polycyclic generators and `n` is + the number of generators in the free_group equal to the length + of pcgs. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> from sympy.combinatorics.permutations import Permutation + >>> G = SymmetricGroup(4) + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> pcgs = PcGroup.pcgs + >>> collector.exponent_vector(G[0]) + [1, 0, 0, 0] + >>> exp = collector.exponent_vector(G[1]) + >>> g = Permutation() + >>> for i in range(len(exp)): + ... g = gpcgs[i]exp[i] if exp[i] else g + >>> assert g == G[1] + + References + ========== + + .. [1] Holt, D., Eick, B., O'Brien, E. + "Handbook of Computational Group Theory" + Section 8.1.1, Definition 8.4 + + """ + free_group = self.free_group + G = PermutationGroup() + for g in self.pcgs: + G = PermutationGroup([g] + G.generators) + gens = G.generator_product(element, original = True) + gens.reverse() + + perm_to_free = {} + for sym, g in zip(free_group.generators, self.pcgs): + perm_to_free[g-1] = sym-1 + perm_to_free[g] = sym + w = free_group.identity + for g in gens: + w = wperm_to_free[g] + + pc_presentation = self.pc_presentation + word = self.collected_word(w) + + index = self.index + exp_vector = [0]*len(free_group) + word = word.array_form + for t in word: + exp_vector[index[t[0]]] = t[1] + return exp_vector + + def depth(self, element): + """ + Return the depth of a given element. + + The depth of a given element `g` is defined by + `dep{g} = i if e{1} = e{2} = ... = e{i-1} = 0` + and `e{i} != 0`, where `e` represents the exponent-vector. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> G = SymmetricGroup(3) + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> collector.depth(G[0]) + 2 + >>> collector.depth(G[1]) + 1 + + References + ========== + + .. [1] Holt, D., Eick, B., O'Brien, E. + "Handbook of Computational Group Theory" + Section 8.1.1, Definition 8.5 + + """ + exp_vector = self.exponent_vector(element) + return next((i+1 for i, x in enumerate(exp_vector) if x), len(self.pcgs)+1) + + def leading_exponent(self, element): + """ + Return the leading non-zero exponent. + + The leading exponent for a given element `g` is defined + by `leading_exponent{g} = e{i}`, if `depth{g} = i`. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> G = SymmetricGroup(3) + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> collector.leading_exponent(G[1]) + 1 + + """ + exp_vector = self.exponent_vector(element) + depth = self.depth(element) + if depth != len(self.pcgs)+1: + return exp_vector[depth-1] + return None diff --git a/sympy/combinatorics/perm_groups.py b/sympy/combinatorics/perm_groups.py index f3f84344db0d..f4e988c7e103 100644 --- a/sympy/combinatorics/perm_groups.py +++ b/sympy/combinatorics/perm_groups.py @@ -4515,6 +4515,32 @@ def _factor_group_by_rels(G, rels): G._fp_presentation = simplify_presentation(G_p) return G._fp_presentation + def polycyclic_group(self): + from sympy.combinatorics.pc_groups import PolycyclicGroup + if not self.is_polycyclic: + raise ValueError("The group must be solvable") + + der = self.derived_series() + pc_series = [] + pc_sequence = [] + relative_order = [] + pc_series.append(der[-1]) + der.reverse() + + for i in range(len(der)-1): + H = der[i] + for g in der[i+1].generators: + if g not in H: + H = PermutationGroup([g] + H.generators) + pc_series.insert(0, H) + pc_sequence.insert(0, g) + + G1 = pc_series[0].order() + G2 = pc_series[1].order() + relative_order.insert(0, G1 // G2) + + return PolycyclicGroup(pc_sequence, pc_series, relative_order, collector=None) + def _orbit(degree, generators, alpha, action='tuples'): r"""Compute the orbit of alpha `\{g(\alpha) \| g \in G\}` as a set.	diff --git a/sympy/combinatorics/tests/test_pc_groups.py b/sympy/combinatorics/tests/test_pc_groups.py new file mode 100644 index 000000000000..ff4b9e7dad55 --- /dev/null +++ b/sympy/combinatorics/tests/test_pc_groups.py @@ -0,0 +1,72 @@ +from sympy.combinatorics.pc_groups import PolycyclicGroup, Collector +from sympy.combinatorics.permutations import Permutation +from sympy.combinatorics.named_groups import SymmetricGroup + +def test_pc_presentation(): + Groups = [SymmetricGroup(3), SymmetricGroup(4), SymmetricGroup(9).sylow_subgroup(3), + SymmetricGroup(9).sylow_subgroup(2), SymmetricGroup(8).sylow_subgroup(2)] + + S = SymmetricGroup(125).sylow_subgroup(5) + G = S.derived_series()[2] + Groups.append(G) + + G = SymmetricGroup(25).sylow_subgroup(5) + Groups.append(G) + + S = SymmetricGroup(11*2).sylow_subgroup(11) + G = S.derived_series()[2] + Groups.append(G) + + for G in Groups: + PcGroup = G.polycyclic_group() + collector = PcGroup.collector + pc_presentation = collector.pc_presentation + + pcgs = PcGroup.pcgs + free_group = collector.free_group + free_to_perm = {} + for s, g in zip(free_group.symbols, pcgs): + free_to_perm[s] = g + + for k, v in pc_presentation.items(): + k_array = k.array_form + if v != (): + v_array = v.array_form + + lhs = Permutation() + for gen in k_array: + s = gen[0] + e = gen[1] + lhs = lhsfree_to_perm[s]*e + + if v == (): + assert lhs.is_identity + continue + + rhs = Permutation() + for gen in v_array: + s = gen[0] + e = gen[1] + rhs = rhsfree_to_perm[s]*e + + assert lhs == rhs + + +def test_exponent_vector(): + + Groups = [SymmetricGroup(3), SymmetricGroup(4), SymmetricGroup(9).sylow_subgroup(3), + SymmetricGroup(9).sylow_subgroup(2), SymmetricGroup(8).sylow_subgroup(2)] + + for G in Groups: + PcGroup = G.polycyclic_group() + collector = PcGroup.collector + + pcgs = PcGroup.pcgs + free_group = collector.free_group + + for gen in G.generators: + exp = collector.exponent_vector(gen) + g = Permutation() + for i in range(len(exp)): + g = gpcgs[i]**exp[i] if exp[i] else g + assert g == gen	diff --git a/doc/src/modules/combinatorics/index.rst b/doc/src/modules/combinatorics/index.rst index f753a41ae16a..2d70a46a13ee 100644 --- a/doc/src/modules/combinatorics/index.rst +++ b/doc/src/modules/combinatorics/index.rst @@ -23,3 +23,4 @@ Contents testutil.rst tensor_can.rst fp_groups.rst + pc_groups.rst diff --git a/doc/src/modules/combinatorics/pc_groups.rst b/doc/src/modules/combinatorics/pc_groups.rst new file mode 100644 index 000000000000..4114bbebebfd --- /dev/null +++ b/doc/src/modules/combinatorics/pc_groups.rst @@ -0,0 +1,12 @@ +.. _combinatorics-pc_groups: + +Polycyclic Groups +================= + +.. module:: sympy.combinatorics.pc_groups + +.. autoclass:: PolycyclicGroup + :members: + +.. autoclass:: Collector + :members: \ No newline at end of file	[ { "components": [ { "doc": "", "lines": [ 7, 22 ], "name": "PolycyclicGroup", "signature": "class PolycyclicGroup(DefaultPrinting):", "type": "class" }, { "doc": "", "lines": [ 12, 16 ...	[ "test_pc_presentation" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added Polycyclic Group Class <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed Polycyclic group class has been added and few of the helper methods are also implemented. #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * combinatorics * added polycyclic group class and methods <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/combinatorics/pc_groups.py] (definition of PolycyclicGroup:) class PolycyclicGroup(DefaultPrinting): (definition of PolycyclicGroup.__init__:) def __init__(self, pc_sequence, pc_series, relative_order, collector=None): (definition of PolycyclicGroup.is_prime_order:) def is_prime_order(self): (definition of PolycyclicGroup.length:) def length(self): (definition of Collector:) class Collector(DefaultPrinting): """References ========== .. [1] Holt, D., Eick, B., O'Brien, E. "Handbook of Computational Group Theory" Section 8.1.3""" (definition of Collector.__init__:) def __init__(self, pcgs, pc_series, relative_order, group=None, pc_presentation=None): (definition of Collector.minimal_uncollected_subword:) def minimal_uncollected_subword(self, word): """Returns the minimal uncollected subwords. A word `v` defined on generators in `X` is a minimal uncollected subword of the word `w` if `v` is a subword of `w` and it has one of the following form i) `v = x[i+1]*a_jx[i]` ii) `v = x[i+1]*a_jx[i]-1` iii) `v = x[i]a_j` for relative_order of `x[i] != infinity` and `a_j` is not in `{1, ..., s-1}`. Where, s is the power exponent of the corresponding generator. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> from sympy.combinatorics.free_groups import free_group >>> G = SymmetricGroup(4) >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> F, x1, x2 = free_group("x1, x2") >>> word = x2*2x17 >>> collector.minimal_uncollected_subword(word) ((x2, 2),)""" (definition of Collector.relations:) def relations(self): """Separates the given relators of pc presentation in power and conjugate relations. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> G = SymmetricGroup(3) >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> power_rel, conj_rel = collector.relations() >>> power_rel {x02: (), x13: ()} >>> conj_rel {x0-1x1x0: x12}""" (definition of Collector.subword_index:) def subword_index(self, word, w): """Returns the start and ending index of a given subword in a word. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> from sympy.combinatorics.free_groups import free_group >>> G = SymmetricGroup(4) >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> F, x1, x2 = free_group("x1, x2") >>> word = x22x17 >>> w = x22x1 >>> collector.subword_index(word, w) (0, 3) >>> w = x1*7 >>> collector.subword_index(word, w) (2, 9)""" (definition of Collector.map_relation:) def map_relation(self, w): """Return a conjugate relation. Given a word formed by two free group elements, the corresponding conjugate relation with those free group elements is formed and mapped with the collected word in the polycyclic presentation. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> from sympy.combinatorics.free_groups import free_group >>> G = SymmetricGroup(3) >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> F, x0, x1 = free_group("x0, x1") >>> w = x1x0 >>> collector.map_relation(w) x12""" (definition of Collector.collected_word:) def collected_word(self, word): """Return the collected form of a word. A word `w` is called collected, if `w = x{i_1}a_1...x{i_r}*a_r` with `i_1 < i_2< ... < i_r` and `a_j` is in `{1, ..., s_j-1}` if `s_j != infinity`. Otherwise w is uncollected. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> from sympy.combinatorics.perm_groups import PermutationGroup >>> from sympy.combinatorics.free_groups import free_group >>> G = SymmetricGroup(4) >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> F, x0, x1, x2, x3 = free_group("x0, x1, x2, x3") >>> word = x3x2x1x0 >>> collected_word = collector.collected_word(word) >>> free_to_perm = {} >>> free_group = collector.free_group >>> for sym, gen in zip(free_group.symbols, collector.pcgs): ... free_to_perm[sym] = gen >>> G1 = PermutationGroup() >>> for w in word: ... sym = w[0] ... perm = free_to_perm[sym] ... G1 = PermutationGroup([perm] + G1.generators) >>> G2 = PermutationGroup() >>> for w in collected_word: ... sym = w[0] ... perm = free_to_perm[sym] ... G2 = PermutationGroup([perm] + G2.generators) >>> G1 == G2 True""" (definition of Collector.pc_relators:) def pc_relators(self): """Return the polycyclic presentation. There are two types of relations used in polycyclic presentation. i) Power relations of the form `x{i}^re{i} = R{i}{i}`, `for 0 <= i < length(pcgs)` where `x` represents polycyclic generator and `re` is the corresponding relative order. ii) Conjugate relations of the form `x{j}^-1x{i}x{j}`, `for 0 <= j < i <= length(pcgs)`. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> from sympy.combinatorics.permutations import Permutation >>> S = SymmetricGroup(49).sylow_subgroup(7) >>> der = S.derived_series() >>> G = der[len(der)-2] >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> pcgs = PcGroup.pcgs >>> len(pcgs) 6 >>> free_group = collector.free_group >>> pc_resentation = collector.pc_presentation >>> free_to_perm = {} >>> for s, g in zip(free_group.symbols, pcgs): ... free_to_perm[s] = g >>> for k, v in pc_resentation.items(): ... k_array = k.array_form ... if v != (): ... v_array = v.array_form ... lhs = Permutation() ... for gen in k_array: ... s = gen[0] ... e = gen[1] ... lhs = lhsfree_to_perm[s]e ... if v == (): ... assert lhs.is_identity ... continue ... rhs = Permutation() ... for gen in v_array: ... s = gen[0] ... e = gen[1] ... rhs = rhsfree_to_perm[s]e ... assert lhs == rhs""" (definition of Collector.exponent_vector:) def exponent_vector(self, element): """Return the exponent vector of length equal to the length of polycyclic generating sequence. For a given generator/element `g` of the polycyclic group, it can be represented as `g = x{1}e{1}....x{n}*e{n}`, where `x{i}` represents polycyclic generators and `n` is the number of generators in the free_group equal to the length of pcgs. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> from sympy.combinatorics.permutations import Permutation >>> G = SymmetricGroup(4) >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> pcgs = PcGroup.pcgs >>> collector.exponent_vector(G[0]) [1, 0, 0, 0] >>> exp = collector.exponent_vector(G[1]) >>> g = Permutation() >>> for i in range(len(exp)): ... g = gpcgs[i]**exp[i] if exp[i] else g >>> assert g == G[1] References ========== .. [1] Holt, D., Eick, B., O'Brien, E. "Handbook of Computational Group Theory" Section 8.1.1, Definition 8.4""" (definition of Collector.depth:) def depth(self, element): """Return the depth of a given element. The depth of a given element `g` is defined by `dep{g} = i if e{1} = e{2} = ... = e{i-1} = 0` and `e{i} != 0`, where `e` represents the exponent-vector. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> G = SymmetricGroup(3) >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> collector.depth(G[0]) 2 >>> collector.depth(G[1]) 1 References ========== .. [1] Holt, D., Eick, B., O'Brien, E. "Handbook of Computational Group Theory" Section 8.1.1, Definition 8.5""" (definition of Collector.leading_exponent:) def leading_exponent(self, element): """Return the leading non-zero exponent. The leading exponent for a given element `g` is defined by `leading_exponent{g} = e{i}`, if `depth{g} = i`. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> G = SymmetricGroup(3) >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> collector.leading_exponent(G[1]) 1""" [end of new definitions in sympy/combinatorics/pc_groups.py] [start of new definitions in sympy/combinatorics/perm_groups.py] (definition of PermutationGroup.polycyclic_group:) def polycyclic_group(self): [end of new definitions in sympy/combinatorics/perm_groups.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-16981	16,981	sympy/sympy	1.5	9576ee3c04cd779524efbf4fe67f1e0658ad93d1	2019-06-06T14:51:24Z	diff --git a/sympy/stats/__init__.py b/sympy/stats/__init__.py index ee5889933ebe..cf0037cab1d7 100644 --- a/sympy/stats/__init__.py +++ b/sympy/stats/__init__.py @@ -80,6 +80,16 @@ ) __all__.extend(joint_rv_types.__all__) +from . import stochastic_process_types +from .stochastic_process_types import ( + StochasticProcess, + DiscreteTimeStochasticProcess, + DiscreteMarkovChain, + TransitionMatrixOf, + StochasticStateSpaceOf +) +__all__.extend(stochastic_process_types.__all__) + from . import symbolic_probability from .symbolic_probability import Probability, Expectation, Variance, Covariance __all__.extend(symbolic_probability.__all__) diff --git a/sympy/stats/rv.py b/sympy/stats/rv.py index c5872bd200a4..353a13974f9d 100644 --- a/sympy/stats/rv.py +++ b/sympy/stats/rv.py @@ -17,7 +17,7 @@ from sympy import (Basic, S, Expr, Symbol, Tuple, And, Add, Eq, lambdify, Equality, Lambda, sympify, Dummy, Ne, KroneckerDelta, - DiracDelta, Mul) + DiracDelta, Mul, Indexed) from sympy.core.compatibility import string_types from sympy.core.relational import Relational from sympy.logic.boolalg import Boolean @@ -268,13 +268,20 @@ def _eval_is_real(self): def is_commutative(self): return self.symbol.is_commutative - def _hashable_content(self): - return self.pspace, self.symbol - @property def free_symbols(self): return {self} +class RandomIndexedSymbol(RandomSymbol): + + def __new__(cls, idx_obj, pspace=None): + if not isinstance(idx_obj, Indexed): + raise TypeError("An indexed object is expected not %s"%(idx_obj)) + return Basic.__new__(cls, idx_obj, pspace) + + symbol = property(lambda self: self.args[0]) + name = symbol + key = property(lambda self: self.symbol.args[1]) class ProductPSpace(PSpace): """ @@ -729,6 +736,9 @@ def probability(condition, given_condition=None, numsamples=None, condition = sympify(condition) given_condition = sympify(given_condition) + if condition.has(RandomIndexedSymbol): + return pspace(condition).probability(condition, given_condition, kwargs) + if isinstance(given_condition, RandomSymbol): condrv = random_symbols(condition) if len(condrv) == 1 and condrv[0] == given_condition: @@ -1385,3 +1395,49 @@ def _value_check(condition, message): if truth == False: raise ValueError(message) return truth == True + +def _symbol_converter(sym): + """ + Casts the parameter to Symbol if it is of string_types + otherwise no operation is performed on it. + + Parameters + ========== + + sym + The parameter to be converted. + + Returns + ======= + + Symbol + the parameter converted to Symbol. + + Raises + ====== + + TypeError + If the parameter is not an instance of both string_types and + Symbol. + + Examples + ======== + + >>> from sympy import Symbol + >>> from sympy.stats.rv import _symbol_converter + >>> s = _symbol_converter('s') + >>> isinstance(s, Symbol) + True + >>> _symbol_converter(1) + Traceback (most recent call last): + ... + TypeError: 1 is neither a Symbol nor a string + >>> r = Symbol('r') + >>> isinstance(r, Symbol) + True + """ + if isinstance(sym, string_types): + sym = Symbol(sym) + if not isinstance(sym, Symbol): + raise TypeError("%s is neither a Symbol nor a string"%(sym)) + return sym diff --git a/sympy/stats/stochastic_process.py b/sympy/stats/stochastic_process.py new file mode 100644 index 000000000000..4520830e1f31 --- /dev/null +++ b/sympy/stats/stochastic_process.py @@ -0,0 +1,77 @@ +from __future__ import print_function, division + +from sympy import Basic, Symbol +from sympy.core.compatibility import string_types +from sympy.stats.rv import ProductDomain +from sympy.stats.joint_rv import ProductPSpace, JointRandomSymbol + +class StochasticPSpace(ProductPSpace): + """ + Represents probability space of stochastic processes + and their random variables. Contains mechanics to do + computations for queries of stochastic processes. + + Initialized by symbol and the specific process. + """ + + def __new__(cls, sym, process): + if isinstance(sym, string_types): + sym = Symbol(sym) + if not isinstance(sym, Symbol): + raise TypeError("Name of stochastic process should be either only " + "a string or Symbol.") + from sympy.stats.stochastic_process_types import StochasticProcess + if not isinstance(process, StochasticProcess): + raise TypeError("`process` must be an instance of StochasticProcess.") + return Basic.__new__(cls, sym, process) + + @property + def process(self): + """ + The associated stochastic process. + """ + return self.args[1] + + @property + def domain(self): + return ProductDomain(self.process.index_set, + self.process.state_space) + + @property + def symbol(self): + return self.args[0] + + def probability(self, condition, given_condition=None, kwargs): + """ + Transfers the task of handling queries to the specific stochastic + process because every process has their own logic of handling such + queries. + """ + return self.process.probability(condition, given_condition, *kwargs) + + def joint_distribution(self, args): + """ + Computes the joint distribution of the random indexed variables. + + Parameters + ========== + + args: iterable + The finite list of random indexed variables of a stochastic + process whose joint distribution has to be computed. + + Returns + ======= + + JointDistribution + The joint distribution of the list of random indexed variables. + An unevaluated object is returned if it is not possible to + compute the joint distribution. + + Raises + ====== + + ValueError: When the time/key of random indexed variables + is not in strictly increasing order. + """ + NotImplementedError() diff --git a/sympy/stats/stochastic_process_types.py b/sympy/stats/stochastic_process_types.py new file mode 100644 index 000000000000..d6eefdc066fb --- /dev/null +++ b/sympy/stats/stochastic_process_types.py @@ -0,0 +1,314 @@ +from sympy import (Symbol, Matrix, MatrixSymbol, S, Indexed, Basic, + Set, And, Tuple, Eq, FiniteSet, ImmutableMatrix, + nsimplify) +from sympy.stats.rv import (RandomIndexedSymbol, random_symbols, RandomSymbol, + _symbol_converter) +from sympy.core.compatibility import string_types +from sympy.core.relational import Relational +from sympy.stats.symbolic_probability import Probability +from sympy.stats.stochastic_process import StochasticPSpace +from sympy.logic.boolalg import Boolean + +__all__ = [ + 'StochasticProcess', + 'DiscreteTimeStochasticProcess', + 'DiscreteMarkovChain', + 'TransitionMatrixOf', + 'StochasticStateSpaceOf' +] + +def _set_converter(itr): + """ + Helper function for converting list/tuple/set to Set. + If parameter is not an instance of list/tuple/set then + no operation is performed. + + Returns + ======= + + Set + The argument converted to Set. + + + Raises + ====== + + TypeError + If the argument is not an instance of list/tuple/set. + """ + if isinstance(itr, (list, tuple, set)): + itr = FiniteSet(itr) + if not isinstance(itr, Set): + raise TypeError("%s is not an instance of list/tuple/set."%(itr)) + return itr + +def _matrix_checks(matrix): + if not isinstance(matrix, (Matrix, MatrixSymbol, ImmutableMatrix)): + raise TypeError("Transition probabilities etiher should " + "be a Matrix or a MatrixSymbol.") + if matrix.shape[0] != matrix.shape[1]: + raise ValueError("%s is not a square matrix"%(matrix)) + if isinstance(matrix, Matrix): + matrix = ImmutableMatrix(matrix.tolist()) + return matrix + +class StochasticProcess(Basic): + """ + Base class for all the stochastic processes whether + discrete or continuous. + + Parameters + ========== + + sym: Symbol or string_types + state_space: Set + The state space of the stochastic process, by default S.Reals. + For discrete sets it is zero indexed. + + See Also + ======== + + DiscreteTimeStochasticProcess + """ + + def __new__(cls, sym, state_space=S.Reals): + sym = _symbol_converter(sym) + state_space = _set_converter(state_space) + return Basic.__new__(cls, sym, state_space) + + @property + def symbol(self): + return self.args[0] + + @property + def state_space(self): + return self.args[1] + + def __call__(self, time): + """ + Overrided in ContinuousTimeStochasticProcess. + """ + raise NotImplementedError("Use [] for indexing discrete time stochastic process.") + + def __getitem__(self, time): + """ + Overrided in DiscreteTimeStochasticProcess. + """ + raise NotImplementedError("Use () for indexing continuous time stochastic process.") + + def probability(self, condition): + raise NotImplementedError() + +class DiscreteTimeStochasticProcess(StochasticProcess): + """ + Base class for all discrete stochastic processes. + """ + def __getitem__(self, time): + """ + For indexing discrete time stochastic processes. + + Returns + ======= + + RandomIndexedSymbol + """ + if time not in self.index_set: + raise IndexError("%s is not in the index set of %s"%(time, self.symbol)) + idx_obj = Indexed(self.symbol, time) + pspace_obj = StochasticPSpace(self.symbol, self) + return RandomIndexedSymbol(idx_obj, pspace_obj) + +class TransitionMatrixOf(Boolean): + """ + Assumes that the matrix is the transition matrix + of the process. + """ + + def __new__(cls, process, matrix): + if not isinstance(process, DiscreteMarkovChain): + raise ValueError("Currently only DiscreteMarkovChain " + "support TransitionMatrixOf.") + matrix = _matrix_checks(matrix) + return Basic.__new__(cls, process, matrix) + + process = property(lambda self: self.args[0]) + matrix = property(lambda self: self.args[1]) + +class StochasticStateSpaceOf(Boolean): + + def __new__(cls, process, state_space): + if not isinstance(process, DiscreteMarkovChain): + raise ValueError("Currently only DiscreteMarkovChain " + "support StochasticStateSpaceOf.") + state_space = _set_converter(state_space) + return Basic.__new__(cls, process, state_space) + + process = property(lambda self: self.args[0]) + state_space = property(lambda self: self.args[1]) + +class DiscreteMarkovChain(DiscreteTimeStochasticProcess): + """ + Represents discrete Markov chain. + + Parameters + ========== + + sym: Symbol + state_space: Set + Optional, by default, S.Reals + trans_probs: Matrix/ImmutableMatrix/MatrixSymbol + Optional, by default, None + + Examples + ======== + + >>> from sympy.stats import DiscreteMarkovChain, TransitionMatrixOf + >>> from sympy import Matrix, MatrixSymbol, Eq + >>> from sympy.stats import P + >>> T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]]) + >>> Y = DiscreteMarkovChain("Y", [0, 1, 2], T) + >>> YS = DiscreteMarkovChain("Y") + >>> Y.state_space + {0, 1, 2} + >>> Y.transition_probabilities + Matrix([ + [0.5, 0.2, 0.3], + [0.2, 0.5, 0.3], + [0.2, 0.3, 0.5]]) + >>> TS = MatrixSymbol('T', 3, 3) + >>> P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TS)) + T[0, 2]T[1, 0] + T[1, 1]T[1, 2] + T[1, 2]T[2, 2] + >>> P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) + 0.36 + """ + + index_set = S.Naturals0 + + def __new__(cls, sym, state_space=S.Reals, trans_probs=None): + sym = _symbol_converter(sym) + state_space = _set_converter(state_space) + if trans_probs != None: + trans_probs = _matrix_checks(trans_probs) + return Basic.__new__(cls, sym, state_space, trans_probs) + + @property + def transition_probabilities(self): + """ + Transition probabilities of discrete Markov chain, + either an instance of Matrix or MatrixSymbol. + """ + return self.args[2] + + def probability(self, condition, given_condition, kwargs): + """ + Handles probability queries for discrete Markov chains. + + Parameters + ========== + + condition: Relational + given_condition: Relational/And + + Returns + ======= + + Probability + If the transition probabilities are not available + Expr + If the transition probabilities is MatrixSymbol or Matrix + + Note + ==== + + Any information passed at the time of query overrides + any information passed at the time of object creation like + transition probabilities, state space. + + Pass the transition matrix using TransitionMatrixOf and state space + using StochasticStateSpaceOf in given_condition using & or And. + """ + + # extracting transition matrix and state space + trans_probs, state_space = self.transition_probabilities, self.state_space + if isinstance(given_condition, And): + gcs = given_condition.args + for gc in gcs: + if isinstance(gc, TransitionMatrixOf): + trans_probs = gc.matrix + if isinstance(gc, StochasticStateSpaceOf): + state_space = gc.state_space + if isinstance(gc, Eq): + given_condition = gc + if isinstance(given_condition, TransitionMatrixOf): + trans_probs = given_condition.matrix + if isinstance(given_condition, StochasticStateSpaceOf): + state_space = given_condition.state_space + + # given_condition does not have sufficient information + # for computations + if trans_probs == None or \ + given_condition == None: + return Probability(condition, given_condition, kwargs) + + # working out transition probabilities + if not isinstance(trans_probs, MatrixSymbol): + rows = trans_probs.tolist() + for row in rows: + if (sum(row) - 1) != 0: + raise ValueError("Probabilities in a row must sum to 1. " + "If you are using Float or floats then please use Rational.") + + # if given condition is None, then there is no need to work out + # state_space from random variables + if given_condition != None: + rand_var = list(given_condition.atoms(RandomSymbol) - + given_condition.atoms(RandomIndexedSymbol)) + if len(rand_var) == 1: + state_space = rand_var[0].pspace.set + if not FiniteSet([i for i in range(trans_probs.shape[0])]).is_subset(state_space): + raise ValueError("state space is not compatible with the transition probabilites.") + + if isinstance(condition, Eq) and \ + isinstance(given_condition, Eq) and \ + len(given_condition.atoms(RandomSymbol)) == 1: + # handles simple queries like P(Eq(X[i], dest_state), Eq(X[i], init_state)) + lhsc, rhsc = condition.lhs, condition.rhs + lhsg, rhsg = given_condition.lhs, given_condition.rhs + if not isinstance(lhsc, RandomIndexedSymbol): + lhsc, rhsc = (rhsc, lhsc) + if not isinstance(lhsg, RandomIndexedSymbol): + lhsg, rhsg = (rhsg, lhsg) + keyc, statec, keyg, stateg = (lhsc.key, rhsc, lhsg.key, rhsg) + if stateg >= trans_probs.shape[0] == False or statec >= trans_probs.shape[1]: + raise IndexError("No information is avaliable for (%s, %s) in " + "transition probabilities of shape, (%s, %s). " + "State space is zero indexed." + %(stateg, statec, trans_probs.shape[0], trans_probs.shape[1])) + if keyc < keyg: + raise ValueError("Incorrect given condition is given, probability " + "of past state cannot be computed from future state.") + nsteptp = trans_probs(keyc - keyg) + if hasattr(nsteptp, "__getitem__"): + return nsteptp.__getitem__((stateg, statec)) + return Indexed(nsteptp, stateg, statec) + + if isinstance(condition, And): + # handle queries like, + # P(Eq(X[i+k], s1) & Eq(X[i+m], s2) . . . & Eq(X[i], sn), Eq(P(X[i]), prob)) + conds = condition.args + i, result = -1, 1 + while i > -len(conds): + result = self.probability(conds[i], conds[i-1] & \ + TransitionMatrixOf(self, trans_probs) & \ + StochasticStateSpaceOf(self, state_space)) + i -= 1 + if isinstance(given_condition, (TransitionMatrixOf, StochasticStateSpaceOf)): + return result * Probability(conds[i]) + if isinstance(given_condition, Eq): + if not isinstance(given_condition.lhs, Probability) or \ + given_condition.lhs.args[0] != conds[i]: + raise ValueError("Probability for %s needed", conds[i]) + return result * given_condition.rhs + + raise NotImplementedError("Mechanism for handling (%s, %s) queries hasn't been " + "implemented yet."%(condition, given_condition))	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index b4912d134d17..c123936675c6 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1530,6 +1530,43 @@ def test_sympy__stats__joint_rv_types__NegativeMultinomialDistribution(): from sympy.stats.joint_rv_types import NegativeMultinomialDistribution assert _test_args(NegativeMultinomialDistribution(5, [0.5, 0.1, 0.3])) +def test_sympy__stats__rv__RandomIndexedSymbol(): + from sympy.stats.rv import RandomIndexedSymbol, pspace + from sympy.tensor import Indexed + from sympy.stats.stochastic_process_types import DiscreteMarkovChain + X = DiscreteMarkovChain("X") + assert _test_args(RandomIndexedSymbol(X[0].symbol, pspace(X[0]))) + +def test_sympy__stats__stochastic_process__StochasticPSpace(): + from sympy.stats.stochastic_process import StochasticPSpace + from sympy.stats.stochastic_process_types import StochasticProcess + assert _test_args(StochasticPSpace("Y", StochasticProcess("Y", [1, 2, 3]))) + +def test_sympy__stats__stochastic_process_types__StochasticProcess(): + from sympy.stats.stochastic_process_types import StochasticProcess + assert _test_args(StochasticProcess("Y", [1, 2, 3])) + +def test_sympy__stats__stochastic_process_types__DiscreteTimeStochasticProcess(): + from sympy.stats.stochastic_process_types import DiscreteTimeStochasticProcess + assert _test_args(DiscreteTimeStochasticProcess("Y", [1, 2, 3])) + +def test_sympy__stats__stochastic_process_types__TransitionMatrixOf(): + from sympy.stats.stochastic_process_types import TransitionMatrixOf, DiscreteMarkovChain + from sympy import MatrixSymbol + DMC = DiscreteMarkovChain("Y") + assert _test_args(TransitionMatrixOf(DMC, MatrixSymbol('T', 3, 3))) + +def test_sympy__stats__stochastic_process_types__StochasticStateSpaceOf(): + from sympy.stats.stochastic_process_types import StochasticStateSpaceOf, DiscreteMarkovChain + from sympy import MatrixSymbol + DMC = DiscreteMarkovChain("Y") + assert _test_args(StochasticStateSpaceOf(DMC, [0, 1, 2])) + +def test_sympy__stats__stochastic_process_types__DiscreteMarkovChain(): + from sympy.stats.stochastic_process_types import DiscreteMarkovChain + from sympy import MatrixSymbol + assert _test_args(DiscreteMarkovChain("Y", [0, 1, 2], MatrixSymbol('T', 3, 3))) + def test_sympy__core__symbol__Dummy(): from sympy.core.symbol import Dummy assert _test_args(Dummy('t')) diff --git a/sympy/stats/tests/test_stochastic_process.py b/sympy/stats/tests/test_stochastic_process.py new file mode 100644 index 000000000000..cd974e42afb0 --- /dev/null +++ b/sympy/stats/tests/test_stochastic_process.py @@ -0,0 +1,41 @@ +from sympy import (S, symbols, FiniteSet, Eq, Matrix, MatrixSymbol, Float, And) +from sympy.stats import DiscreteMarkovChain, P, TransitionMatrixOf +from sympy.stats.rv import RandomIndexedSymbol +from sympy.stats.symbolic_probability import Probability +from sympy.utilities.pytest import raises + +def test_DiscreteMarkovChain(): + + # pass only the name + X = DiscreteMarkovChain("X") + assert X.state_space == S.Reals + assert X.index_set == S.Naturals0 + assert X.transition_probabilities == None + t = symbols('t', positive=True, integer=True) + assert isinstance(X[t], RandomIndexedSymbol) + + # pass name and state_space + Y = DiscreteMarkovChain("Y", [1, 2, 3]) + assert Y.transition_probabilities == None + assert Y.state_space == FiniteSet(1, 2, 3) + assert P(Eq(Y[2], 1), Eq(Y[0], 2)) == Probability(Eq(Y[2], 1), Eq(Y[0], 2)) + + # pass name, state_space and transition_probabilities + T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]]) + TS = MatrixSymbol('T', 3, 3) + Y = DiscreteMarkovChain("Y", [0, 1, 2], T) + YS = DiscreteMarkovChain("Y", [0, 1, 2], TS) + assert P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) == Float(0.36, 2) + assert str(P(Eq(YS[3], 2), Eq(YS[1], 1))) == \ + "T[0, 2]T[1, 0] + T[1, 1]T[1, 2] + T[1, 2]*T[2, 2]" + TO = Matrix([[0.25, 0.75, 0],[0, 0.25, 0.75],[0.75, 0, 0.25]]) + assert P(Eq(Y[3], 2), Eq(Y[1], 1) & TransitionMatrixOf(Y, TO)).round(3) == Float(0.375, 3) + TSO = MatrixSymbol('T', 4, 4) + raises(ValueError, lambda: str(P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TSO)))) + + # extended tests for probability queries + TO1 = Matrix([[S(1)/4, S(3)/4, 0],[S(1)/3, S(1)/3, S(1)/3],[0, S(1)/4, S(3)/4]]) + assert P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)), + Eq(Probability(Eq(Y[0], 0)), S(1)/4) & TransitionMatrixOf(Y, TO1)) == S(1)/16 + assert P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)), TransitionMatrixOf(Y, TO1)) == \ + Probability(Eq(Y[0], 0))/4		[ { "components": [ { "doc": "", "lines": [ 275, 284 ], "name": "RandomIndexedSymbol", "signature": "class RandomIndexedSymbol(RandomSymbol):", "type": "class" }, { "doc": "", "lines": [ 277, ...	[ "test_sympy__stats__rv__RandomIndexedSymbol", "test_sympy__stats__stochastic_process__StochasticPSpace", "test_sympy__stats__stochastic_process_types__StochasticProcess", "test_sympy__stats__stochastic_process_types__DiscreteTimeStochasticProcess", "test_sympy__stats__stochastic_process_types__TransitionMat...	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added StochasticProcess and DiscreteMarkovChain <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> [1] https://github.com/sympy/sympy/issues/16895 #### Brief description of what is fixed or changed `StochasticPSpace` has been added to `sympy.stats.stochastic_process`, `StochasticProcess` and `DiscreteMarkovChain` has been added to `sympy.stats.stochastic_process_types`. Associated tests have also been added. Currently the `DiscreteMarkovChain` handles only probability queries More features, like expectation, joint_distribution will be done in other PRs so that it is easier to review. #### Other comments Following are the references for the additions, 1. API - https://github.com/sympy/sympy/issues/16895#issuecomment-497649797 2. StochasticPSpace - https://github.com/sympy/sympy/issues/16895#issuecomment-498039663 3. RandomIndexedSymbol - https://github.com/sympy/sympy/pull/16852#issuecomment-493765433, https://github.com/sympy/sympy/pull/16866/files#r286833831 #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * stats * `StochasticProcess` and `DiscreteMarkovChain` added to `sympy.stats`. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/rv.py] (definition of RandomIndexedSymbol:) class RandomIndexedSymbol(RandomSymbol): (definition of RandomIndexedSymbol.__new__:) def __new__(cls, idx_obj, pspace=None): (definition of _symbol_converter:) def _symbol_converter(sym): """Casts the parameter to Symbol if it is of string_types otherwise no operation is performed on it. Parameters ========== sym The parameter to be converted. Returns ======= Symbol the parameter converted to Symbol. Raises ====== TypeError If the parameter is not an instance of both string_types and Symbol. Examples ======== >>> from sympy import Symbol >>> from sympy.stats.rv import _symbol_converter >>> s = _symbol_converter('s') >>> isinstance(s, Symbol) True >>> _symbol_converter(1) Traceback (most recent call last): ... TypeError: 1 is neither a Symbol nor a string >>> r = Symbol('r') >>> isinstance(r, Symbol) True""" [end of new definitions in sympy/stats/rv.py] [start of new definitions in sympy/stats/stochastic_process.py] (definition of StochasticPSpace:) class StochasticPSpace(ProductPSpace): """Represents probability space of stochastic processes and their random variables. Contains mechanics to do computations for queries of stochastic processes. Initialized by symbol and the specific process.""" (definition of StochasticPSpace.__new__:) def __new__(cls, sym, process): (definition of StochasticPSpace.process:) def process(self): """The associated stochastic process.""" (definition of StochasticPSpace.domain:) def domain(self): (definition of StochasticPSpace.symbol:) def symbol(self): (definition of StochasticPSpace.probability:) def probability(self, condition, given_condition=None, *kwargs): """Transfers the task of handling queries to the specific stochastic process because every process has their own logic of handling such queries.""" (definition of StochasticPSpace.joint_distribution:) def joint_distribution(self, args): """Computes the joint distribution of the random indexed variables. Parameters ========== args: iterable The finite list of random indexed variables of a stochastic process whose joint distribution has to be computed. Returns ======= JointDistribution The joint distribution of the list of random indexed variables. An unevaluated object is returned if it is not possible to compute the joint distribution. Raises ====== ValueError: When the time/key of random indexed variables is not in strictly increasing order.""" [end of new definitions in sympy/stats/stochastic_process.py] [start of new definitions in sympy/stats/stochastic_process_types.py] (definition of _set_converter:) def _set_converter(itr): """Helper function for converting list/tuple/set to Set. If parameter is not an instance of list/tuple/set then no operation is performed. Returns ======= Set The argument converted to Set. Raises ====== TypeError If the argument is not an instance of list/tuple/set.""" (definition of _matrix_checks:) def _matrix_checks(matrix): (definition of StochasticProcess:) class StochasticProcess(Basic): """Base class for all the stochastic processes whether discrete or continuous. Parameters ========== sym: Symbol or string_types state_space: Set The state space of the stochastic process, by default S.Reals. For discrete sets it is zero indexed. See Also ======== DiscreteTimeStochasticProcess""" (definition of StochasticProcess.__new__:) def __new__(cls, sym, state_space=S.Reals): (definition of StochasticProcess.symbol:) def symbol(self): (definition of StochasticProcess.state_space:) def state_space(self): (definition of StochasticProcess.__call__:) def __call__(self, time): """Overrided in ContinuousTimeStochasticProcess.""" (definition of StochasticProcess.__getitem__:) def __getitem__(self, time): """Overrided in DiscreteTimeStochasticProcess.""" (definition of StochasticProcess.probability:) def probability(self, condition): (definition of DiscreteTimeStochasticProcess:) class DiscreteTimeStochasticProcess(StochasticProcess): """Base class for all discrete stochastic processes.""" (definition of DiscreteTimeStochasticProcess.__getitem__:) def __getitem__(self, time): """For indexing discrete time stochastic processes. Returns ======= RandomIndexedSymbol""" (definition of TransitionMatrixOf:) class TransitionMatrixOf(Boolean): """Assumes that the matrix is the transition matrix of the process.""" (definition of TransitionMatrixOf.__new__:) def __new__(cls, process, matrix): (definition of StochasticStateSpaceOf:) class StochasticStateSpaceOf(Boolean): (definition of StochasticStateSpaceOf.__new__:) def __new__(cls, process, state_space): (definition of DiscreteMarkovChain:) class DiscreteMarkovChain(DiscreteTimeStochasticProcess): """Represents discrete Markov chain. Parameters ========== sym: Symbol state_space: Set Optional, by default, S.Reals trans_probs: Matrix/ImmutableMatrix/MatrixSymbol Optional, by default, None Examples ======== >>> from sympy.stats import DiscreteMarkovChain, TransitionMatrixOf >>> from sympy import Matrix, MatrixSymbol, Eq >>> from sympy.stats import P >>> T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]]) >>> Y = DiscreteMarkovChain("Y", [0, 1, 2], T) >>> YS = DiscreteMarkovChain("Y") >>> Y.state_space {0, 1, 2} >>> Y.transition_probabilities Matrix([ [0.5, 0.2, 0.3], [0.2, 0.5, 0.3], [0.2, 0.3, 0.5]]) >>> TS = MatrixSymbol('T', 3, 3) >>> P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TS)) T[0, 2]T[1, 0] + T[1, 1]T[1, 2] + T[1, 2]T[2, 2] >>> P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) 0.36""" (definition of DiscreteMarkovChain.__new__:) def __new__(cls, sym, state_space=S.Reals, trans_probs=None): (definition of DiscreteMarkovChain.transition_probabilities:) def transition_probabilities(self): """Transition probabilities of discrete Markov chain, either an instance of Matrix or MatrixSymbol.""" (definition of DiscreteMarkovChain.probability:) def probability(self, condition, given_condition, *kwargs): """Handles probability queries for discrete Markov chains. Parameters ========== condition: Relational given_condition: Relational/And Returns ======= Probability If the transition probabilities are not available Expr If the transition probabilities is MatrixSymbol or Matrix Note ==== Any information passed at the time of query overrides any information passed at the time of object creation like transition probabilities, state space. Pass the transition matrix using TransitionMatrixOf and state space using StochasticStateSpaceOf in given_condition using & or And.""" [end of new definitions in sympy/stats/stochastic_process_types.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
dpkp__kafka-python-1833	1,833	dpkp/kafka-python	null	79dd508b14fd2d66a8b6d32353e8e64989c4ff84	2019-06-03T20:40:19Z	diff --git a/kafka/admin/__init__.py b/kafka/admin/__init__.py index a300301c6..c240fc6d0 100644 --- a/kafka/admin/__init__.py +++ b/kafka/admin/__init__.py @@ -2,9 +2,13 @@ from kafka.admin.config_resource import ConfigResource, ConfigResourceType from kafka.admin.client import KafkaAdminClient +from kafka.admin.acl_resource import (ACL, ACLFilter, ResourcePattern, ResourcePatternFilter, ACLOperation, + ResourceType, ACLPermissionType, ACLResourcePatternType) from kafka.admin.new_topic import NewTopic from kafka.admin.new_partitions import NewPartitions __all__ = [ - 'ConfigResource', 'ConfigResourceType', 'KafkaAdminClient', 'NewTopic', 'NewPartitions' + 'ConfigResource', 'ConfigResourceType', 'KafkaAdminClient', 'NewTopic', 'NewPartitions', 'ACL', 'ACLFilter', + 'ResourcePattern', 'ResourcePatternFilter', 'ACLOperation', 'ResourceType', 'ACLPermissionType', + 'ACLResourcePatternType' ] diff --git a/kafka/admin/acl_resource.py b/kafka/admin/acl_resource.py new file mode 100644 index 000000000..7a012d2fa --- /dev/null +++ b/kafka/admin/acl_resource.py @@ -0,0 +1,212 @@ +from __future__ import absolute_import +from kafka.errors import IllegalArgumentError + +# enum in stdlib as of py3.4 +try: + from enum import IntEnum # pylint: disable=import-error +except ImportError: + # vendored backport module + from kafka.vendor.enum34 import IntEnum + + +class ResourceType(IntEnum): + """Type of kafka resource to set ACL for + + The ANY value is only valid in a filter context + """ + + UNKNOWN = 0, + ANY = 1, + CLUSTER = 4, + DELEGATION_TOKEN = 6, + GROUP = 3, + TOPIC = 2, + TRANSACTIONAL_ID = 5 + + +class ACLOperation(IntEnum): + """Type of operation + + The ANY value is only valid in a filter context + """ + + ANY = 1, + ALL = 2, + READ = 3, + WRITE = 4, + CREATE = 5, + DELETE = 6, + ALTER = 7, + DESCRIBE = 8, + CLUSTER_ACTION = 9, + DESCRIBE_CONFIGS = 10, + ALTER_CONFIGS = 11, + IDEMPOTENT_WRITE = 12 + + +class ACLPermissionType(IntEnum): + """An enumerated type of permissions + + The ANY value is only valid in a filter context + """ + + ANY = 1, + DENY = 2, + ALLOW = 3 + + +class ACLResourcePatternType(IntEnum): + """An enumerated type of resource patterns + + More details on the pattern types and how they work + can be found in KIP-290 (Support for prefixed ACLs) + https://cwiki.apache.org/confluence/display/KAFKA/KIP-290%3A+Support+for+Prefixed+ACLs + """ + + ANY = 1, + MATCH = 2, + LITERAL = 3, + PREFIXED = 4 + + +class ACLFilter(object): + """Represents a filter to use with describing and deleting ACLs + + The difference between this class and the ACL class is mainly that + we allow using ANY with the operation, permission, and resource type objects + to fetch ALCs matching any of the properties. + + To make a filter matching any principal, set principal to None + """ + + def __init__( + self, + principal, + host, + operation, + permission_type, + resource_pattern + ): + self.principal = principal + self.host = host + self.operation = operation + self.permission_type = permission_type + self.resource_pattern = resource_pattern + + self.validate() + + def validate(self): + if not isinstance(self.operation, ACLOperation): + raise IllegalArgumentError("operation must be an ACLOperation object, and cannot be ANY") + if not isinstance(self.permission_type, ACLPermissionType): + raise IllegalArgumentError("permission_type must be an ACLPermissionType object, and cannot be ANY") + if not isinstance(self.resource_pattern, ResourcePatternFilter): + raise IllegalArgumentError("resource_pattern must be a ResourcePatternFilter object") + + def __repr__(self): + return "<ACL principal={principal}, resource={resource}, operation={operation}, type={type}, host={host}>".format( + principal=self.principal, + host=self.host, + operation=self.operation.name, + type=self.permission_type.name, + resource=self.resource_pattern + ) + + +class ACL(ACLFilter): + """Represents a concrete ACL for a specific ResourcePattern + + In kafka an ACL is a 4-tuple of (principal, host, operation, permission_type) + that limits who can do what on a specific resource (or since KIP-290 a resource pattern) + + Terminology: + Principal -> This is the identifier for the user. Depending on the authorization method used (SSL, SASL etc) + the principal will look different. See http://kafka.apache.org/documentation/#security_authz for details. + The principal must be on the format "User:<name>" or kafka will treat it as invalid. It's possible to use + other principal types than "User" if using a custom authorizer for the cluster. + Host -> This must currently be an IP address. It cannot be a range, and it cannot be a domain name. + It can be set to "*", which is special cased in kafka to mean "any host" + Operation -> Which client operation this ACL refers to. Has different meaning depending + on the resource type the ACL refers to. See https://docs.confluent.io/current/kafka/authorization.html#acl-format + for a list of which combinations of resource/operation that unlocks which kafka APIs + Permission Type: Whether this ACL is allowing or denying access + Resource Pattern -> This is a representation of the resource or resource pattern that the ACL + refers to. See the ResourcePattern class for details. + + """ + + def __init__( + self, + principal, + host, + operation, + permission_type, + resource_pattern + ): + super(ACL, self).__init__(principal, host, operation, permission_type, resource_pattern) + self.validate() + + def validate(self): + if self.operation == ACLOperation.ANY: + raise IllegalArgumentError("operation cannot be ANY") + if self.permission_type == ACLPermissionType.ANY: + raise IllegalArgumentError("permission_type cannot be ANY") + if not isinstance(self.resource_pattern, ResourcePattern): + raise IllegalArgumentError("resource_pattern must be a ResourcePattern object") + + +class ResourcePatternFilter(object): + def __init__( + self, + resource_type, + resource_name, + pattern_type + ): + self.resource_type = resource_type + self.resource_name = resource_name + self.pattern_type = pattern_type + + self.validate() + + def validate(self): + if not isinstance(self.resource_type, ResourceType): + raise IllegalArgumentError("resource_type must be a ResourceType object") + if not isinstance(self.pattern_type, ACLResourcePatternType): + raise IllegalArgumentError("pattern_type must be an ACLResourcePatternType object") + + def __repr__(self): + return "<ResourcePattern type={}, name={}, pattern={}>".format( + self.resource_type.name, + self.resource_name, + self.pattern_type.name + ) + + +class ResourcePattern(ResourcePatternFilter): + """A resource pattern to apply the ACL to + + Resource patterns are used to be able to specify which resources an ACL + describes in a more flexible way than just pointing to a literal topic name for example. + Since KIP-290 (kafka 2.0) it's possible to set an ACL for a prefixed resource name, which + can cut down considerably on the number of ACLs needed when the number of topics and + consumer groups start to grow. + The default pattern_type is LITERAL, and it describes a specific resource. This is also how + ACLs worked before the introduction of prefixed ACLs + """ + + def __init__( + self, + resource_type, + resource_name, + pattern_type=ACLResourcePatternType.LITERAL + ): + super(ResourcePattern, self).__init__(resource_type, resource_name, pattern_type) + self.validate() + + def validate(self): + if self.resource_type == ResourceType.ANY: + raise IllegalArgumentError("resource_type cannot be ANY") + if self.pattern_type in [ACLResourcePatternType.ANY, ACLResourcePatternType.MATCH]: + raise IllegalArgumentError( + "pattern_type cannot be {} on a concrete ResourcePattern".format(self.pattern_type.name) + ) \ No newline at end of file diff --git a/kafka/admin/client.py b/kafka/admin/client.py index 155ad21d6..0e3e8a184 100644 --- a/kafka/admin/client.py +++ b/kafka/admin/client.py @@ -11,14 +11,16 @@ import kafka.errors as Errors from kafka.errors import ( IncompatibleBrokerVersion, KafkaConfigurationError, NotControllerError, - UnrecognizedBrokerVersion) + UnrecognizedBrokerVersion, IllegalArgumentError) from kafka.metrics import MetricConfig, Metrics from kafka.protocol.admin import ( CreateTopicsRequest, DeleteTopicsRequest, DescribeConfigsRequest, AlterConfigsRequest, CreatePartitionsRequest, - ListGroupsRequest, DescribeGroupsRequest) + ListGroupsRequest, DescribeGroupsRequest, DescribeAclsRequest, CreateAclsRequest, DeleteAclsRequest) from kafka.protocol.commit import GroupCoordinatorRequest, OffsetFetchRequest from kafka.protocol.metadata import MetadataRequest from kafka.structs import TopicPartition, OffsetAndMetadata +from kafka.admin.acl_resource import ACLOperation, ACLPermissionType, ACLFilter, ACL, ResourcePattern, ResourceType, \ + ACLResourcePatternType from kafka.version import __version__ @@ -450,14 +452,269 @@ def delete_topics(self, topics, timeout_ms=None): # describe cluster functionality is in ClusterMetadata # Note: if implemented here, send the request to the least_loaded_node() - # describe_acls protocol not yet implemented - # Note: send the request to the least_loaded_node() + @staticmethod + def _convert_describe_acls_response_to_acls(describe_response): + version = describe_response.API_VERSION + + error = Errors.for_code(describe_response.error_code) + acl_list = [] + for resources in describe_response.resources: + if version == 0: + resource_type, resource_name, acls = resources + resource_pattern_type = ACLResourcePatternType.LITERAL.value + elif version <= 1: + resource_type, resource_name, resource_pattern_type, acls = resources + else: + raise NotImplementedError( + "Support for DescribeAcls Response v{} has not yet been added to KafkaAdmin." + .format(version) + ) + for acl in acls: + principal, host, operation, permission_type = acl + conv_acl = ACL( + principal=principal, + host=host, + operation=ACLOperation(operation), + permission_type=ACLPermissionType(permission_type), + resource_pattern=ResourcePattern( + ResourceType(resource_type), + resource_name, + ACLResourcePatternType(resource_pattern_type) + ) + ) + acl_list.append(conv_acl) + + return (acl_list, error,) + + def describe_acls(self, acl_filter): + """Describe a set of ACLs + + Used to return a set of ACLs matching the supplied ACLFilter. + The cluster must be configured with an authorizer for this to work, or + you will get a SecurityDisabledError + + :param acl_filter: an ACLFilter object + :return: tuple of a list of matching ACL objects and a KafkaError (NoError if successful) + """ - # create_acls protocol not yet implemented - # Note: send the request to the least_loaded_node() + version = self._matching_api_version(DescribeAclsRequest) + if version == 0: + request = DescribeAclsRequest[version]( + resource_type=acl_filter.resource_pattern.resource_type, + resource_name=acl_filter.resource_pattern.resource_name, + principal=acl_filter.principal, + host=acl_filter.host, + operation=acl_filter.operation, + permission_type=acl_filter.permission_type + ) + elif version <= 1: + request = DescribeAclsRequest[version]( + resource_type=acl_filter.resource_pattern.resource_type, + resource_name=acl_filter.resource_pattern.resource_name, + resource_pattern_type_filter=acl_filter.resource_pattern.pattern_type, + principal=acl_filter.principal, + host=acl_filter.host, + operation=acl_filter.operation, + permission_type=acl_filter.permission_type - # delete_acls protocol not yet implemented - # Note: send the request to the least_loaded_node() + ) + else: + raise NotImplementedError( + "Support for DescribeAcls v{} has not yet been added to KafkaAdmin." + .format(version) + ) + + future = self._send_request_to_node(self._client.least_loaded_node(), request) + self._wait_for_futures([future]) + response = future.value + + error_type = Errors.for_code(response.error_code) + if error_type is not Errors.NoError: + # optionally we could retry if error_type.retriable + raise error_type( + "Request '{}' failed with response '{}'." + .format(request, response)) + + return self._convert_describe_acls_response_to_acls(response) + + @staticmethod + def _convert_create_acls_resource_request_v0(acl): + + return ( + acl.resource_pattern.resource_type, + acl.resource_pattern.resource_name, + acl.principal, + acl.host, + acl.operation, + acl.permission_type + ) + + @staticmethod + def _convert_create_acls_resource_request_v1(acl): + + return ( + acl.resource_pattern.resource_type, + acl.resource_pattern.resource_name, + acl.resource_pattern.pattern_type, + acl.principal, + acl.host, + acl.operation, + acl.permission_type + ) + + @staticmethod + def _convert_create_acls_response_to_acls(acls, create_response): + version = create_response.API_VERSION + + creations_error = [] + creations_success = [] + for i, creations in enumerate(create_response.creation_responses): + if version <= 1: + error_code, error_message = creations + acl = acls[i] + error = Errors.for_code(error_code) + else: + raise NotImplementedError( + "Support for DescribeAcls Response v{} has not yet been added to KafkaAdmin." + .format(version) + ) + + if error is Errors.NoError: + creations_success.append(acl) + else: + creations_error.append((acl, error,)) + + return {"succeeded": creations_success, "failed": creations_error} + + def create_acls(self, acls): + """Create a list of ACLs + + This endpoint only accepts a list of concrete ACL objects, no ACLFilters. + Throws TopicAlreadyExistsError if topic is already present. + + :param acls: a list of ACL objects + :return: dict of successes and failures + """ + + for acl in acls: + if not isinstance(acl, ACL): + raise IllegalArgumentError("acls must contain ACL objects") + + version = self._matching_api_version(CreateAclsRequest) + if version == 0: + request = CreateAclsRequest[version]( + creations=[self._convert_create_acls_resource_request_v0(acl) for acl in acls] + ) + elif version <= 1: + request = CreateAclsRequest[version]( + creations=[self._convert_create_acls_resource_request_v1(acl) for acl in acls] + ) + else: + raise NotImplementedError( + "Support for CreateAcls v{} has not yet been added to KafkaAdmin." + .format(version) + ) + + future = self._send_request_to_node(self._client.least_loaded_node(), request) + self._wait_for_futures([future]) + response = future.value + + + return self._convert_create_acls_response_to_acls(acls, response) + + @staticmethod + def _convert_delete_acls_resource_request_v0(acl): + return ( + acl.resource_pattern.resource_type, + acl.resource_pattern.resource_name, + acl.principal, + acl.host, + acl.operation, + acl.permission_type + ) + + @staticmethod + def _convert_delete_acls_resource_request_v1(acl): + return ( + acl.resource_pattern.resource_type, + acl.resource_pattern.resource_name, + acl.resource_pattern.pattern_type, + acl.principal, + acl.host, + acl.operation, + acl.permission_type + ) + + @staticmethod + def _convert_delete_acls_response_to_matching_acls(acl_filters, delete_response): + version = delete_response.API_VERSION + filter_result_list = [] + for i, filter_responses in enumerate(delete_response.filter_responses): + filter_error_code, filter_error_message, matching_acls = filter_responses + filter_error = Errors.for_code(filter_error_code) + acl_result_list = [] + for acl in matching_acls: + if version == 0: + error_code, error_message, resource_type, resource_name, principal, host, operation, permission_type = acl + resource_pattern_type = ACLResourcePatternType.LITERAL.value + elif version == 1: + error_code, error_message, resource_type, resource_name, resource_pattern_type, principal, host, operation, permission_type = acl + else: + raise NotImplementedError( + "Support for DescribeAcls Response v{} has not yet been added to KafkaAdmin." + .format(version) + ) + acl_error = Errors.for_code(error_code) + conv_acl = ACL( + principal=principal, + host=host, + operation=ACLOperation(operation), + permission_type=ACLPermissionType(permission_type), + resource_pattern=ResourcePattern( + ResourceType(resource_type), + resource_name, + ACLResourcePatternType(resource_pattern_type) + ) + ) + acl_result_list.append((conv_acl, acl_error,)) + filter_result_list.append((acl_filters[i], acl_result_list, filter_error,)) + return filter_result_list + + def delete_acls(self, acl_filters): + """Delete a set of ACLs + + Deletes all ACLs matching the list of input ACLFilter + + :param acl_filters: a list of ACLFilter + :return: a list of 3-tuples corresponding to the list of input filters. + The tuples hold (the input ACLFilter, list of affected ACLs, KafkaError instance) + """ + + for acl in acl_filters: + if not isinstance(acl, ACLFilter): + raise IllegalArgumentError("acl_filters must contain ACLFilter type objects") + + version = self._matching_api_version(DeleteAclsRequest) + + if version == 0: + request = DeleteAclsRequest[version]( + filters=[self._convert_delete_acls_resource_request_v0(acl) for acl in acl_filters] + ) + elif version <= 1: + request = DeleteAclsRequest[version]( + filters=[self._convert_delete_acls_resource_request_v1(acl) for acl in acl_filters] + ) + else: + raise NotImplementedError( + "Support for DeleteAcls v{} has not yet been added to KafkaAdmin." + .format(version) + ) + + future = self._send_request_to_node(self._client.least_loaded_node(), request) + self._wait_for_futures([future]) + response = future.value + + return self._convert_delete_acls_response_to_matching_acls(acl_filters, response) @staticmethod def _convert_describe_config_resource_request(config_resource): diff --git a/kafka/errors.py b/kafka/errors.py index f13f97853..abef2c5bf 100644 --- a/kafka/errors.py +++ b/kafka/errors.py @@ -443,6 +443,12 @@ class PolicyViolationError(BrokerResponseError): description = 'Request parameters do not satisfy the configured policy.' +class SecurityDisabledError(BrokerResponseError): + errno = 54 + message = 'SECURITY_DISABLED' + description = 'Security features are disabled.' + + class KafkaUnavailableError(KafkaError): pass diff --git a/servers/0.10.0.0/resources/kafka.properties b/servers/0.10.0.0/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.10.0.0/resources/kafka.properties +++ b/servers/0.10.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.10.0.1/resources/kafka.properties b/servers/0.10.0.1/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.10.0.1/resources/kafka.properties +++ b/servers/0.10.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.10.1.1/resources/kafka.properties b/servers/0.10.1.1/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.10.1.1/resources/kafka.properties +++ b/servers/0.10.1.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.10.2.1/resources/kafka.properties b/servers/0.10.2.1/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.10.2.1/resources/kafka.properties +++ b/servers/0.10.2.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.11.0.0/resources/kafka.properties b/servers/0.11.0.0/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/0.11.0.0/resources/kafka.properties +++ b/servers/0.11.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.11.0.1/resources/kafka.properties b/servers/0.11.0.1/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/0.11.0.1/resources/kafka.properties +++ b/servers/0.11.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.11.0.2/resources/kafka.properties b/servers/0.11.0.2/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/0.11.0.2/resources/kafka.properties +++ b/servers/0.11.0.2/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.9.0.0/resources/kafka.properties b/servers/0.9.0.0/resources/kafka.properties index b4c4088db..a8aaa284a 100644 --- a/servers/0.9.0.0/resources/kafka.properties +++ b/servers/0.9.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.9.0.1/resources/kafka.properties b/servers/0.9.0.1/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.9.0.1/resources/kafka.properties +++ b/servers/0.9.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.0.0/resources/kafka.properties b/servers/1.0.0/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/1.0.0/resources/kafka.properties +++ b/servers/1.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.0.1/resources/kafka.properties b/servers/1.0.1/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/1.0.1/resources/kafka.properties +++ b/servers/1.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.0.2/resources/kafka.properties b/servers/1.0.2/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/1.0.2/resources/kafka.properties +++ b/servers/1.0.2/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.1.0/resources/kafka.properties b/servers/1.1.0/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/1.1.0/resources/kafka.properties +++ b/servers/1.1.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.1.1/resources/kafka.properties b/servers/1.1.1/resources/kafka.properties index 64f94d528..fe6a89f4a 100644 --- a/servers/1.1.1/resources/kafka.properties +++ b/servers/1.1.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # List of enabled mechanisms, can be more than one sasl.enabled.mechanisms=PLAIN sasl.mechanism.inter.broker.protocol=PLAIN diff --git a/servers/2.0.0/resources/kafka.properties b/servers/2.0.0/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/2.0.0/resources/kafka.properties +++ b/servers/2.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/2.0.1/resources/kafka.properties b/servers/2.0.1/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/2.0.1/resources/kafka.properties +++ b/servers/2.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092	diff --git a/test/test_admin.py b/test/test_admin.py index 300d5bced..279f85abf 100644 --- a/test/test_admin.py +++ b/test/test_admin.py @@ -26,6 +26,37 @@ def test_new_partitions(): assert good_partitions.new_assignments == [[1, 2, 3]] +def test_acl_resource(): + good_acl = kafka.admin.ACL( + "User:bar", + "", + kafka.admin.ACLOperation.ALL, + kafka.admin.ACLPermissionType.ALLOW, + kafka.admin.ResourcePattern( + kafka.admin.ResourceType.TOPIC, + "foo", + kafka.admin.ACLResourcePatternType.LITERAL + ) + ) + + assert(good_acl.resource_pattern.resource_type == kafka.admin.ResourceType.TOPIC) + assert(good_acl.operation == kafka.admin.ACLOperation.ALL) + assert(good_acl.permission_type == kafka.admin.ACLPermissionType.ALLOW) + assert(good_acl.resource_pattern.pattern_type == kafka.admin.ACLResourcePatternType.LITERAL) + + with pytest.raises(IllegalArgumentError): + kafka.admin.ACL( + "User:bar", + "", + kafka.admin.ACLOperation.ANY, + kafka.admin.ACLPermissionType.ANY, + kafka.admin.ResourcePattern( + kafka.admin.ResourceType.TOPIC, + "foo", + kafka.admin.ACLResourcePatternType.LITERAL + ) + ) + def test_new_topic(): with pytest.raises(IllegalArgumentError): bad_topic = kafka.admin.NewTopic('foo', -1, -1) diff --git a/test/test_admin_integration.py b/test/test_admin_integration.py new file mode 100644 index 000000000..0be192001 --- /dev/null +++ b/test/test_admin_integration.py @@ -0,0 +1,107 @@ +import pytest +import os + +from test.fixtures import ZookeeperFixture, KafkaFixture, version +from test.testutil import KafkaIntegrationTestCase, kafka_versions, current_offset + +from kafka.errors import NoError +from kafka.admin import KafkaAdminClient, ACLFilter, ACLOperation, ACLPermissionType, ResourcePattern, ResourceType, ACL + + +class TestAdminClientIntegration(KafkaIntegrationTestCase): + @classmethod + def setUpClass(cls): # noqa + if not os.environ.get('KAFKA_VERSION'): + return + + cls.zk = ZookeeperFixture.instance() + cls.server = KafkaFixture.instance(0, cls.zk) + + @classmethod + def tearDownClass(cls): # noqa + if not os.environ.get('KAFKA_VERSION'): + return + + cls.server.close() + cls.zk.close() + + @kafka_versions('>=0.9.0') + def test_create_describe_delete_acls(self): + """Tests that we can add, list and remove ACLs + """ + + # Setup + brokers = '%s:%d' % (self.server.host, self.server.port) + admin_client = KafkaAdminClient( + bootstrap_servers=brokers + ) + + # Check that we don't have any ACLs in the cluster + acls, error = admin_client.describe_acls( + ACLFilter( + principal=None, + host="", + operation=ACLOperation.ANY, + permission_type=ACLPermissionType.ANY, + resource_pattern=ResourcePattern(ResourceType.TOPIC, "topic") + ) + ) + + self.assertIs(error, NoError) + self.assertEqual(0, len(acls)) + + # Try to add an ACL + acl = ACL( + principal="User:test", + host="", + operation=ACLOperation.READ, + permission_type=ACLPermissionType.ALLOW, + resource_pattern=ResourcePattern(ResourceType.TOPIC, "topic") + ) + result = admin_client.create_acls([acl]) + + self.assertFalse(len(result["failed"])) + self.assertEqual(len(result["succeeded"]), 1) + + # Check that we can list the ACL we created + acl_filter = ACLFilter( + principal=None, + host="", + operation=ACLOperation.ANY, + permission_type=ACLPermissionType.ANY, + resource_pattern=ResourcePattern(ResourceType.TOPIC, "topic") + ) + acls, error = admin_client.describe_acls(acl_filter) + + self.assertIs(error, NoError) + self.assertEqual(1, len(acls)) + + # Remove the ACL + delete_results = admin_client.delete_acls( + [ + ACLFilter( + principal="User:test", + host="", + operation=ACLOperation.READ, + permission_type=ACLPermissionType.ALLOW, + resource_pattern=ResourcePattern(ResourceType.TOPIC, "topic") + ) + ] + ) + + self.assertEqual(1, len(delete_results)) + self.assertEqual(1, len(delete_results[0][1])) # Check number of affected ACLs + + + # Make sure the ACL does not exist in the cluster anymore + acls, error = admin_client.describe_acls( + ACLFilter( + principal="", + host="", + operation=ACLOperation.ANY, + permission_type=ACLPermissionType.ANY, + resource_pattern=ResourcePattern(ResourceType.TOPIC, "topic") + ) + ) + self.assertIs(error, NoError) + self.assertEqual(0, len(acls))	diff --git a/servers/0.10.0.0/resources/kafka.properties b/servers/0.10.0.0/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.10.0.0/resources/kafka.properties +++ b/servers/0.10.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.10.0.1/resources/kafka.properties b/servers/0.10.0.1/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.10.0.1/resources/kafka.properties +++ b/servers/0.10.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.10.1.1/resources/kafka.properties b/servers/0.10.1.1/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.10.1.1/resources/kafka.properties +++ b/servers/0.10.1.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.10.2.1/resources/kafka.properties b/servers/0.10.2.1/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.10.2.1/resources/kafka.properties +++ b/servers/0.10.2.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.11.0.0/resources/kafka.properties b/servers/0.11.0.0/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/0.11.0.0/resources/kafka.properties +++ b/servers/0.11.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.11.0.1/resources/kafka.properties b/servers/0.11.0.1/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/0.11.0.1/resources/kafka.properties +++ b/servers/0.11.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.11.0.2/resources/kafka.properties b/servers/0.11.0.2/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/0.11.0.2/resources/kafka.properties +++ b/servers/0.11.0.2/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.9.0.0/resources/kafka.properties b/servers/0.9.0.0/resources/kafka.properties index b4c4088db..a8aaa284a 100644 --- a/servers/0.9.0.0/resources/kafka.properties +++ b/servers/0.9.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.9.0.1/resources/kafka.properties b/servers/0.9.0.1/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.9.0.1/resources/kafka.properties +++ b/servers/0.9.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.0.0/resources/kafka.properties b/servers/1.0.0/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/1.0.0/resources/kafka.properties +++ b/servers/1.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.0.1/resources/kafka.properties b/servers/1.0.1/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/1.0.1/resources/kafka.properties +++ b/servers/1.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.0.2/resources/kafka.properties b/servers/1.0.2/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/1.0.2/resources/kafka.properties +++ b/servers/1.0.2/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.1.0/resources/kafka.properties b/servers/1.1.0/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/1.1.0/resources/kafka.properties +++ b/servers/1.1.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.1.1/resources/kafka.properties b/servers/1.1.1/resources/kafka.properties index 64f94d528..fe6a89f4a 100644 --- a/servers/1.1.1/resources/kafka.properties +++ b/servers/1.1.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # List of enabled mechanisms, can be more than one sasl.enabled.mechanisms=PLAIN sasl.mechanism.inter.broker.protocol=PLAIN diff --git a/servers/2.0.0/resources/kafka.properties b/servers/2.0.0/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/2.0.0/resources/kafka.properties +++ b/servers/2.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/2.0.1/resources/kafka.properties b/servers/2.0.1/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/2.0.1/resources/kafka.properties +++ b/servers/2.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092	[ { "components": [ { "doc": "Type of kafka resource to set ACL for\n\nThe ANY value is only valid in a filter context", "lines": [ 12, 24 ], "name": "ResourceType", "signature": "class ResourceType(IntEnum):", "type": "class" }, ...	[ "test/test_admin.py::test_config_resource", "test/test_admin.py::test_new_partitions", "test/test_admin.py::test_acl_resource", "test/test_admin.py::test_new_topic" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add ACL api to KafkaAdminClient This is a new attempt at creating user friendly ACL management methods to KafkaAdminClient. It's building on top of the previous PR (#1646) that only got the protocol stuff merged b.c there were remaining issues to deal with in the api part, and not much time. I think I've covered all the feedback from that PR in this one. I'm ready for a new round of review, hopefully I can find enough time for fixes and tweaks to land the whole thing this time =) Fixes #1638 <!-- Reviewable:start --> --- This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/dpkp/kafka-python/1833) <!-- Reviewable:end --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in kafka/admin/acl_resource.py] (definition of ResourceType:) class ResourceType(IntEnum): """Type of kafka resource to set ACL for The ANY value is only valid in a filter context""" (definition of ACLOperation:) class ACLOperation(IntEnum): """Type of operation The ANY value is only valid in a filter context""" (definition of ACLPermissionType:) class ACLPermissionType(IntEnum): """An enumerated type of permissions The ANY value is only valid in a filter context""" (definition of ACLResourcePatternType:) class ACLResourcePatternType(IntEnum): """An enumerated type of resource patterns More details on the pattern types and how they work can be found in KIP-290 (Support for prefixed ACLs) https://cwiki.apache.org/confluence/display/KAFKA/KIP-290%3A+Support+for+Prefixed+ACLs""" (definition of ACLFilter:) class ACLFilter(object): """Represents a filter to use with describing and deleting ACLs The difference between this class and the ACL class is mainly that we allow using ANY with the operation, permission, and resource type objects to fetch ALCs matching any of the properties. To make a filter matching any principal, set principal to None""" (definition of ACLFilter.__init__:) def __init__( self, principal, host, operation, permission_type, resource_pattern ): (definition of ACLFilter.validate:) def validate(self): (definition of ACLFilter.__repr__:) def __repr__(self): (definition of ACL:) class ACL(ACLFilter): """Represents a concrete ACL for a specific ResourcePattern In kafka an ACL is a 4-tuple of (principal, host, operation, permission_type) that limits who can do what on a specific resource (or since KIP-290 a resource pattern) Terminology: Principal -> This is the identifier for the user. Depending on the authorization method used (SSL, SASL etc) the principal will look different. See http://kafka.apache.org/documentation/#security_authz for details. The principal must be on the format "User:<name>" or kafka will treat it as invalid. It's possible to use other principal types than "User" if using a custom authorizer for the cluster. Host -> This must currently be an IP address. It cannot be a range, and it cannot be a domain name. It can be set to "*", which is special cased in kafka to mean "any host" Operation -> Which client operation this ACL refers to. Has different meaning depending on the resource type the ACL refers to. See https://docs.confluent.io/current/kafka/authorization.html#acl-format for a list of which combinations of resource/operation that unlocks which kafka APIs Permission Type: Whether this ACL is allowing or denying access Resource Pattern -> This is a representation of the resource or resource pattern that the ACL refers to. See the ResourcePattern class for details.""" (definition of ACL.__init__:) def __init__( self, principal, host, operation, permission_type, resource_pattern ): (definition of ACL.validate:) def validate(self): (definition of ResourcePatternFilter:) class ResourcePatternFilter(object): (definition of ResourcePatternFilter.__init__:) def __init__( self, resource_type, resource_name, pattern_type ): (definition of ResourcePatternFilter.validate:) def validate(self): (definition of ResourcePatternFilter.__repr__:) def __repr__(self): (definition of ResourcePattern:) class ResourcePattern(ResourcePatternFilter): """A resource pattern to apply the ACL to Resource patterns are used to be able to specify which resources an ACL describes in a more flexible way than just pointing to a literal topic name for example. Since KIP-290 (kafka 2.0) it's possible to set an ACL for a prefixed resource name, which can cut down considerably on the number of ACLs needed when the number of topics and consumer groups start to grow. The default pattern_type is LITERAL, and it describes a specific resource. This is also how ACLs worked before the introduction of prefixed ACLs""" (definition of ResourcePattern.__init__:) def __init__( self, resource_type, resource_name, pattern_type=ACLResourcePatternType.LITERAL ): (definition of ResourcePattern.validate:) def validate(self): [end of new definitions in kafka/admin/acl_resource.py] [start of new definitions in kafka/admin/client.py] (definition of KafkaAdminClient._convert_describe_acls_response_to_acls:) def _convert_describe_acls_response_to_acls(describe_response): (definition of KafkaAdminClient.describe_acls:) def describe_acls(self, acl_filter): """Describe a set of ACLs Used to return a set of ACLs matching the supplied ACLFilter. The cluster must be configured with an authorizer for this to work, or you will get a SecurityDisabledError :param acl_filter: an ACLFilter object :return: tuple of a list of matching ACL objects and a KafkaError (NoError if successful)""" (definition of KafkaAdminClient._convert_create_acls_resource_request_v0:) def _convert_create_acls_resource_request_v0(acl): (definition of KafkaAdminClient._convert_create_acls_resource_request_v1:) def _convert_create_acls_resource_request_v1(acl): (definition of KafkaAdminClient._convert_create_acls_response_to_acls:) def _convert_create_acls_response_to_acls(acls, create_response): (definition of KafkaAdminClient.create_acls:) def create_acls(self, acls): """Create a list of ACLs This endpoint only accepts a list of concrete ACL objects, no ACLFilters. Throws TopicAlreadyExistsError if topic is already present. :param acls: a list of ACL objects :return: dict of successes and failures""" (definition of KafkaAdminClient._convert_delete_acls_resource_request_v0:) def _convert_delete_acls_resource_request_v0(acl): (definition of KafkaAdminClient._convert_delete_acls_resource_request_v1:) def _convert_delete_acls_resource_request_v1(acl): (definition of KafkaAdminClient._convert_delete_acls_response_to_matching_acls:) def _convert_delete_acls_response_to_matching_acls(acl_filters, delete_response): (definition of KafkaAdminClient.delete_acls:) def delete_acls(self, acl_filters): """Delete a set of ACLs Deletes all ACLs matching the list of input ACLFilter :param acl_filters: a list of ACLFilter :return: a list of 3-tuples corresponding to the list of input filters. The tuples hold (the input ACLFilter, list of affected ACLs, KafkaError instance)""" [end of new definitions in kafka/admin/client.py] [start of new definitions in kafka/errors.py] (definition of SecurityDisabledError:) class SecurityDisabledError(BrokerResponseError): [end of new definitions in kafka/errors.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Add ACL kafka protocols to AdminClient I could not find any mention in these issues of adding ACL protocols to this project. Is that something that would be attractive to add? I could try and add the Create/Delete/Describe protocols and implement methods for them in the AdminClient in that case. I'm currently using the kafka supplied shellscripts for managing Acls, but I find them very clunky and resource heavy, so being able to use kafka-python for that would be great =) ---------- Great idea! I havent looked at ACL admin protocols. On Thu, Nov 15, 2018, 3:07 PM Ulrik Johansson <notifications@github.com wrote: > I could not find any mention in these issues of adding ACL protocols to > this project. Is that something that would be attractive to add? > I could try and add the Create/Delete/Describe protocols and implement > methods for them in the AdminClient in that case. > > I'm currently using the kafka supplied shellscripts for managing Acls, but > I find them very clunky and resource heavy, so being able to use > kafka-python for that would be great =) > > — > You are receiving this because you are subscribed to this thread. > Reply to this email directly, view it on GitHub > <https://github.com/dpkp/kafka-python/issues/1638>, or mute the thread > <https://github.com/notifications/unsubscribe-auth/AAzetA2glKIx-j3uihRHC50_FijEGZ1nks5uvfOxgaJpZM4Yjl5m> > . > -------------------- </issues>	53dc740bce8ef19c32fad2881021d1f6bb055f7a
joke2k__faker-964	964	joke2k/faker	null	89eefd7962928b3150e72707fc8718613ab63e63	2019-05-27T10:39:41Z	diff --git a/faker/providers/person/pl_PL/__init__.py b/faker/providers/person/pl_PL/__init__.py index 49c622df8a..025b50f135 100644 --- a/faker/providers/person/pl_PL/__init__.py +++ b/faker/providers/person/pl_PL/__init__.py @@ -21,28 +21,6 @@ def checksum_identity_card_number(characters): return check_digit -def generate_pesel_checksum_value(pesel_digits): - """ - Calculates and returns a control digit for given PESEL. - """ - checksum_values = [9, 7, 3, 1, 9, 7, 3, 1, 9, 7] - - checksum = sum((int(a) * b for a, b in zip(list(pesel_digits), checksum_values))) - - return checksum % 10 - - -def checksum_pesel_number(pesel_digits): - """ - Calculates and returns True if PESEL is valid. - """ - checksum_values = [1, 3, 7, 9, 1, 3, 7, 9, 1, 3, 1] - - checksum = sum((int(a) * b for a, b in zip(list(pesel_digits), checksum_values))) - - return checksum % 10 == 0 - - class Provider(PersonProvider): formats = ( '{{first_name}} {{last_name}}', @@ -725,30 +703,74 @@ def identity_card_number(self): return ''.join(str(character) for character in identity) - def pesel(self): + @staticmethod + def pesel_compute_check_digit(pesel): + checksum_values = [9, 7, 3, 1, 9, 7, 3, 1, 9, 7] + return sum(int(a) * b for a, b in zip(pesel, checksum_values)) % 10 + + def pesel(self, date_of_birth=None, sex=None): """ Returns 11 characters of Universal Electronic System for Registration of the Population. Polish: Powszechny Elektroniczny System Ewidencji Ludności. PESEL has 11 digits which identifies just one person. - Month: if person was born in 1900-2000, december is 12. If person was born > 2000, we have to add 20 to month, - so december is 32. - Person id: last digit identifies person's sex. Even for females, odd for males. + pesel_date: if person was born in 1900-2000, december is 12. If person was born > 2000, we have to add 20 to + month, so december is 32. + pesel_sex: last digit identifies person's sex. Even for females, odd for males. https://en.wikipedia.org/wiki/PESEL """ + if date_of_birth is None: + date_of_birth = self.generator.date_of_birth() - birth = self.generator.date_of_birth() + pesel_date = '{year}{month:02d}{day:02d}'.format( + year=date_of_birth.year, day=date_of_birth.day, + month=date_of_birth.month if date_of_birth.year < 2000 else date_of_birth.month + 20) + pesel_date = pesel_date[2:] - year_pesel = str(birth.year)[-2:] - month_pesel = birth.month if birth.year < 2000 else birth.month + 20 - day_pesel = birth.day - person_id = self.random_int(1000, 9999) + pesel_core = ''.join(map(str, (self.random_digit() for _ in range(3)))) + pesel_sex = self.random_digit() - current_pesel = '{year}{month:02d}{day:02d}{person_id:04d}'.format(year=year_pesel, month=month_pesel, - day=day_pesel, - person_id=person_id) + if (sex == 'M' and pesel_sex % 2 == 0) or (sex == 'F' and pesel_sex % 2 == 1): + pesel_sex = (pesel_sex + 1) % 10 + + pesel = '{date}{core}{sex}'.format(date=pesel_date, core=pesel_core, sex=pesel_sex) + pesel += str(self.pesel_compute_check_digit(pesel)) + + return pesel + + @staticmethod + def pwz_doctor_compute_check_digit(x): + return sum((i+1)*d for i, d in enumerate(x)) % 11 + + def pwz_doctor(self): + """ + Function generates an identification number for medical doctors + Polish: Prawo Wykonywania Zawodu (PWZ) + + https://www.nil.org.pl/rejestry/centralny-rejestr-lekarzy/zasady-weryfikowania-nr-prawa-wykonywania-zawodu + """ + core = [self.random_digit() for _ in range(6)] + check_digit = self.pwz_doctor_compute_check_digit(core) + + if check_digit == 0: + core[-1] = (core[-1] + 1) % 10 + check_digit = self.pwz_doctor_compute_check_digit(core) + + return '{}{}'.format(check_digit, ''.join(map(str, core))) + + def pwz_nurse(self, kind='nurse'): + """ + Function generates an identification number for nurses and midwives + Polish: Prawo Wykonywania Zawodu (PWZ) + + http://arch.nipip.pl/index.php/prawo/uchwaly/naczelnych-rad/w-roku-2015/posiedzenie-15-17-grudnia/3664-uchwala- + nr-381-vi-2015-w-sprawie-trybu-postepowania-dotyczacego-stwierdzania-i-przyznawania-prawa-wykonywania-zawodu-pi + elegniarki-i-zawodu-poloznej-oraz-sposobu-prowadzenia-rejestru-pielegniarek-i-rejestru-poloznych-przez-okregowe + -rady-pielegniarek-i-polo + """ + region = self.random_int(1, 45) + core = [self.random_digit() for _ in range(5)] + kind_char = 'A' if kind == 'midwife' else 'P' - checksum_value = generate_pesel_checksum_value(current_pesel) - return '{pesel_without_checksum}{checksum_value}'.format(pesel_without_checksum=current_pesel, - checksum_value=checksum_value) + return '{:02d}{}{}'.format(region, ''.join(map(str, core)), kind_char)	diff --git a/tests/providers/test_person.py b/tests/providers/test_person.py index 3767ef4d89..90b8d4c2ca 100644 --- a/tests/providers/test_person.py +++ b/tests/providers/test_person.py @@ -4,9 +4,14 @@ import re import unittest - +import datetime import six +try: + from unittest import mock +except ImportError: + import mock + from faker import Faker from faker.providers.person.ar_AA import Provider as ArProvider from faker.providers.person.fi_FI import Provider as FiProvider @@ -14,9 +19,9 @@ from faker.providers.person.ne_NP import Provider as NeProvider from faker.providers.person.sv_SE import Provider as SvSEProvider from faker.providers.person.cs_CZ import Provider as CsCZProvider +from faker.providers.person.pl_PL import Provider as PlPLProvider from faker.providers.person.pl_PL import ( checksum_identity_card_number as pl_checksum_identity_card_number, - checksum_pesel_number as pl_checksum_pesel_number, ) from faker.providers.person.zh_CN import Provider as ZhCNProvider from faker.providers.person.zh_TW import Provider as ZhTWProvider @@ -207,13 +212,43 @@ def test_identity_card_number(self): for _ in range(100): assert re.search(r'^[A-Z]{3}\d{6}$', self.factory.identity_card_number()) - def test_pesel_number_checksum(self): - assert pl_checksum_pesel_number('31090655159') is True - assert pl_checksum_pesel_number('95030853577') is True - assert pl_checksum_pesel_number('05260953442') is True - assert pl_checksum_pesel_number('31090655158') is False - assert pl_checksum_pesel_number('95030853576') is False - assert pl_checksum_pesel_number('05260953441') is False + @mock.patch.object(PlPLProvider, 'random_digit') + def test_pesel_birth_date(self, mock_random_digit): + mock_random_digit.side_effect = [3, 5, 8, 8, 7, 9, 9, 3] + assert self.factory.pesel(datetime.date(1999, 12, 31)) == '99123135885' + assert self.factory.pesel(datetime.date(2000, 1, 1)) == '00210179936' + + @mock.patch.object(PlPLProvider, 'random_digit') + def test_pesel_sex_male(self, mock_random_digit): + mock_random_digit.side_effect = [1, 3, 4, 5, 6, 1, 7, 0] + assert self.factory.pesel(datetime.date(1909, 3, 3), 'M') == '09030313454' + assert self.factory.pesel(datetime.date(1913, 8, 16), 'M') == '13081661718' + + @mock.patch.object(PlPLProvider, 'random_digit') + def test_pesel_sex_female(self, mock_random_digit): + mock_random_digit.side_effect = [4, 9, 1, 6, 6, 1, 7, 3] + assert self.factory.pesel(datetime.date(2007, 4, 13), 'F') == '07241349161' + assert self.factory.pesel(datetime.date(1933, 12, 16), 'F') == '33121661744' + + @mock.patch.object(PlPLProvider, 'random_digit') + def test_pwz_doctor(self, mock_random_digit): + mock_random_digit.side_effect = [6, 9, 1, 9, 6, 5, 2, 7, 9, 9, 1, 5] + assert self.factory.pwz_doctor() == '2691965' + assert self.factory.pwz_doctor() == '4279915' + + @mock.patch.object(PlPLProvider, 'random_digit') + def test_pwz_doctor_check_digit_zero(self, mock_random_digit): + mock_random_digit.side_effect = [0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 9, 9] + assert self.factory.pwz_doctor() == '6000012' + assert self.factory.pwz_doctor() == '1000090' + + @mock.patch.object(PlPLProvider, 'random_int') + @mock.patch.object(PlPLProvider, 'random_digit') + def test_pwz_nurse(self, mock_random_digit, mock_random_int): + mock_random_digit.side_effect = [3, 4, 5, 6, 7, 1, 7, 5, 1, 2] + mock_random_int.side_effect = [45, 3] + assert self.factory.pwz_nurse(kind='nurse') == '4534567P' + assert self.factory.pwz_nurse(kind='midwife') == '0317512A' class TestCsCZ(unittest.TestCase):		[ { "components": [ { "doc": "", "lines": [ 707, 709 ], "name": "Provider.pesel_compute_check_digit", "signature": "def pesel_compute_check_digit(pesel):", "type": "function" }, { "doc": "", "lines": [ ...	[ "tests/providers/test_person.py::TestPlPL::test_pesel_birth_date", "tests/providers/test_person.py::TestPlPL::test_pesel_sex_female", "tests/providers/test_person.py::TestPlPL::test_pesel_sex_male", "tests/providers/test_person.py::TestPlPL::test_pwz_doctor", "tests/providers/test_person.py::TestPlPL::test_...	[ "tests/providers/test_person.py::TestAr::test_first_name", "tests/providers/test_person.py::TestAr::test_last_name", "tests/providers/test_person.py::TestJaJP::test_person", "tests/providers/test_person.py::TestNeNP::test_names", "tests/providers/test_person.py::TestFiFI::test_gender_first_names", "tests/...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> add pwz generator and date_of_brith and sex asargument to pesel (`pl_PL`) What does this changes - `Person` in `pl_PL` What was wrong - it wasn't possible to generate pesel number for given date of birth and/or sex - generator for a `pwz` number was unavailable How this fixes it - adds pwz_doctor and pwz_nurse generator to `Person` (pl_PL) - adds date_of_birth and sex as parameter to `Person.pesel` (pl_PL) Fixes #931 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/person/pl_PL/__init__.py] (definition of Provider.pesel_compute_check_digit:) def pesel_compute_check_digit(pesel): (definition of Provider.pwz_doctor_compute_check_digit:) def pwz_doctor_compute_check_digit(x): (definition of Provider.pwz_doctor:) def pwz_doctor(self): """Function generates an identification number for medical doctors Polish: Prawo Wykonywania Zawodu (PWZ) https://www.nil.org.pl/rejestry/centralny-rejestr-lekarzy/zasady-weryfikowania-nr-prawa-wykonywania-zawodu""" (definition of Provider.pwz_nurse:) def pwz_nurse(self, kind='nurse'): """Function generates an identification number for nurses and midwives Polish: Prawo Wykonywania Zawodu (PWZ) http://arch.nipip.pl/index.php/prawo/uchwaly/naczelnych-rad/w-roku-2015/posiedzenie-15-17-grudnia/3664-uchwala- nr-381-vi-2015-w-sprawie-trybu-postepowania-dotyczacego-stwierdzania-i-przyznawania-prawa-wykonywania-zawodu-pi elegniarki-i-zawodu-poloznej-oraz-sposobu-prowadzenia-rejestru-pielegniarek-i-rejestru-poloznych-przez-okregowe -rady-pielegniarek-i-polo""" [end of new definitions in faker/providers/person/pl_PL/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> pl_PL tasks - a lot of things to add Hi, I'm using faker quite often, but there is some missing functionalities for pl_PL, like e.g. PESEL generator (Polish id for every person), car plates or some more. Can I contribute on my own branch (e.g. pl-PL-features or something), to add missing functionalities? ---------- Hi @adwojak , Thank for reaching out! Feel free to fork the repo, create your branch and submit Pull Requests! Thanks a lot! -------------------- </issues>	6edfdbf6ae90b0153309e3bf066aa3b2d16494a7
scrapy__scrapy-3796	3,796	scrapy/scrapy	null	a3d38041e230f886d55569f861a11a96ab8a1913	2019-05-27T06:17:15Z	diff --git a/.travis.yml b/.travis.yml index 08b0bf1195c..dc333a2012d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -26,6 +26,12 @@ matrix: sudo: true - python: 3.6 env: TOXENV=docs + - python: 3.7 + env: TOXENV=py37-extra-deps + dist: xenial + sudo: true + - python: 2.7 + env: TOXENV=py27-extra-deps install: - \| if [ "$TOXENV" = "pypy" ]; then diff --git a/docs/topics/downloader-middleware.rst b/docs/topics/downloader-middleware.rst index f2f3ef46657..ae1086ee10e 100644 --- a/docs/topics/downloader-middleware.rst +++ b/docs/topics/downloader-middleware.rst @@ -922,6 +922,17 @@ RobotsTxtMiddleware To make sure Scrapy respects robots.txt make sure the middleware is enabled and the :setting:`ROBOTSTXT_OBEY` setting is enabled. + This middleware has to be combined with a robots.txt_ parser. + + Scrapy ships with support for the following robots.txt_ parsers: + + * :ref:`RobotFileParser <python-robotfileparser>` (default) + * :ref:`Reppy <reppy-parser>` + * :ref:`Robotexclusionrulesparser <rerp-parser>` + + You can change the robots.txt_ parser with the :setting:`ROBOTSTXT_PARSER` + setting. Or you can also :ref:`implement support for a new parser <support-for-new-robots-parser>`. + .. reqmeta:: dont_obey_robotstxt If :attr:`Request.meta <scrapy.http.Request.meta>` has @@ -929,6 +940,74 @@ If :attr:`Request.meta <scrapy.http.Request.meta>` has the request will be ignored by this middleware even if :setting:`ROBOTSTXT_OBEY` is enabled. +.. _python-robotfileparser: + +RobotFileParser +~~~~~~~~~~~~~~~ + +`RobotFileParser <https://docs.python.org/3.7/library/urllib.robotparser.html>`_ is +Python's inbuilt ``robots.txt`` parser. The parser is fully compliant with `Martijn Koster's +1996 draft specification <http://www.robotstxt.org/norobots-rfc.txt>`_. It lacks +support for wildcard matching. Scrapy uses this parser by default. + +In order to use this parser, set: + +* :setting:`ROBOTSTXT_PARSER` to ``scrapy.robotstxt.PythonRobotParser`` + +.. _rerp-parser: + +Robotexclusionrulesparser +~~~~~~~~~~~~~~~~~~~~~~~~~ + +`Robotexclusionrulesparser <http://nikitathespider.com/python/rerp/>`_ is fully compliant +with `Martijn Koster's 1996 draft specification <http://www.robotstxt.org/norobots-rfc.txt>`_, +with support for wildcard matching. + +In order to use this parser: + +* Install `Robotexclusionrulesparser <http://nikitathespider.com/python/rerp/>`_ by running + ``pip install robotexclusionrulesparser`` + +* Set :setting:`ROBOTSTXT_PARSER` setting to + ``scrapy.robotstxt.RerpRobotParser`` + +.. _reppy-parser: + +Reppy parser +~~~~~~~~~~~~ + +`Reppy <https://github.com/seomoz/reppy/>`_ is a Python wrapper around `Robots Exclusion +Protocol Parser for C++ <https://github.com/seomoz/rep-cpp>`_. The parser is fully compliant +with `Martijn Koster's 1996 draft specification <http://www.robotstxt.org/norobots-rfc.txt>`_, +with support for wildcard matching. Unlike +`RobotFileParser <https://docs.python.org/3.7/library/urllib.robotparser.html>`_ and +`Robotexclusionrulesparser <http://nikitathespider.com/python/rerp/>`_, it uses the length based +rule, in particular for ``Allow`` and ``Disallow`` directives, where the most specific +rule based on the length of the path trumps the less specific (shorter) rule. + +In order to use this parser: + +* Install `Reppy <https://github.com/seomoz/reppy/>`_ by running ``pip install reppy`` + +* Set :setting:`ROBOTSTXT_PARSER` setting to + ``scrapy.robotstxt.ReppyRobotParser`` + +.. _support-for-new-robots-parser: + +Implementing support for a new parser +------------------------------------- + +You can implement support for a new robots.txt_ parser by subclassing +the abstract base class :class:`~scrapy.robotstxt.RobotParser` and +implementing the methods described below. + +.. module:: scrapy.robotstxt + :synopsis: robots.txt parser interface and implementations + +.. autoclass:: RobotParser + :members: + +.. _robots.txt: http://www.robotstxt.org/ DownloaderStats --------------- diff --git a/docs/topics/settings.rst b/docs/topics/settings.rst index 371f21c72f5..0d3eaa094c8 100644 --- a/docs/topics/settings.rst +++ b/docs/topics/settings.rst @@ -1113,6 +1113,16 @@ If enabled, Scrapy will respect robots.txt policies. For more information see this option is enabled by default in settings.py file generated by ``scrapy startproject`` command. +.. setting:: ROBOTSTXT_PARSER + +ROBOTSTXT_PARSER +---------------- + +Default: ``'scrapy.robotstxt.PythonRobotParser'`` + +The parser backend to use for parsing ``robots.txt`` files. For more information see +:ref:`topics-dlmw-robots`. + .. setting:: SCHEDULER SCHEDULER diff --git a/scrapy/downloadermiddlewares/robotstxt.py b/scrapy/downloadermiddlewares/robotstxt.py index 200245210ec..c5a60d355e2 100644 --- a/scrapy/downloadermiddlewares/robotstxt.py +++ b/scrapy/downloadermiddlewares/robotstxt.py @@ -5,8 +5,8 @@ """ import logging - -from six.moves.urllib import robotparser +import sys +import re from twisted.internet.defer import Deferred, maybeDeferred from scrapy.exceptions import NotConfigured, IgnoreRequest @@ -14,6 +14,7 @@ from scrapy.utils.httpobj import urlparse_cached from scrapy.utils.log import failure_to_exc_info from scrapy.utils.python import to_native_str +from scrapy.utils.misc import load_object logger = logging.getLogger(__name__) @@ -24,10 +25,13 @@ class RobotsTxtMiddleware(object): def __init__(self, crawler): if not crawler.settings.getbool('ROBOTSTXT_OBEY'): raise NotConfigured - + self._default_useragent = crawler.settings.get('USER_AGENT', 'Scrapy') self.crawler = crawler - self._useragent = crawler.settings.get('USER_AGENT') self._parsers = {} + self._parserimpl = load_object(crawler.settings.get('ROBOTSTXT_PARSER')) + + # check if parser dependencies are met, this should throw an error otherwise. + self._parserimpl.from_crawler(self.crawler, b'') @classmethod def from_crawler(cls, crawler): @@ -43,7 +47,8 @@ def process_request(self, request, spider): def process_request_2(self, rp, request, spider): if rp is None: return - if not rp.can_fetch(to_native_str(self._useragent), request.url): + useragent = request.headers.get(b'User-Agent', self._default_useragent) + if not rp.allowed(request.url, useragent): logger.debug("Forbidden by robots.txt: %(request)s", {'request': request}, extra={'spider': spider}) self.crawler.stats.inc_value('robotstxt/forbidden') @@ -62,13 +67,14 @@ def robot_parser(self, request, spider): meta={'dont_obey_robotstxt': True} ) dfd = self.crawler.engine.download(robotsreq, spider) - dfd.addCallback(self._parse_robots, netloc) + dfd.addCallback(self._parse_robots, netloc, spider) dfd.addErrback(self._logerror, robotsreq, spider) dfd.addErrback(self._robots_error, netloc) self.crawler.stats.inc_value('robotstxt/request_count') if isinstance(self._parsers[netloc], Deferred): d = Deferred() + def cb(result): d.callback(result) return result @@ -85,27 +91,10 @@ def _logerror(self, failure, request, spider): extra={'spider': spider}) return failure - def _parse_robots(self, response, netloc): + def _parse_robots(self, response, netloc, spider): self.crawler.stats.inc_value('robotstxt/response_count') - self.crawler.stats.inc_value( - 'robotstxt/response_status_count/{}'.format(response.status)) - rp = robotparser.RobotFileParser(response.url) - body = '' - if hasattr(response, 'text'): - body = response.text - else: # last effort try - try: - body = response.body.decode('utf-8') - except UnicodeDecodeError: - # If we found garbage, disregard it:, - # but keep the lookup cached (in self._parsers) - # Running rp.parse() will set rp state from - # 'disallow all' to 'allow any'. - self.crawler.stats.inc_value('robotstxt/unicode_error_count') - # stdlib's robotparser expects native 'str' ; - # with unicode input, non-ASCII encoded bytes decoding fails in Python2 - rp.parse(to_native_str(body).splitlines()) - + self.crawler.stats.inc_value('robotstxt/response_status_count/{}'.format(response.status)) + rp = self._parserimpl.from_crawler(self.crawler, response.body) rp_dfd = self._parsers[netloc] self._parsers[netloc] = rp rp_dfd.callback(rp) diff --git a/scrapy/robotstxt.py b/scrapy/robotstxt.py new file mode 100644 index 00000000000..4bfb275fdcd --- /dev/null +++ b/scrapy/robotstxt.py @@ -0,0 +1,112 @@ +import sys +import logging +from abc import ABCMeta, abstractmethod +from six import with_metaclass + +from scrapy.utils.python import to_native_str, to_unicode + +logger = logging.getLogger(__name__) + + +class RobotParser(with_metaclass(ABCMeta)): + @classmethod + @abstractmethod + def from_crawler(cls, crawler, robotstxt_body): + """Parse the content of a robots.txt_ file as bytes. This must be a class method. + It must return a new instance of the parser backend. + + :param crawler: crawler which made the request + :type crawler: :class:`~scrapy.crawler.Crawler` instance + + :param robotstxt_body: content of a robots.txt_ file. + :type robotstxt_body: bytes + """ + pass + + @abstractmethod + def allowed(self, url, user_agent): + """Return ``True`` if ``user_agent`` is allowed to crawl ``url``, otherwise return ``False``. + + :param url: Absolute URL + :type url: string + + :param user_agent: User agent + :type user_agent: string + """ + pass + + +class PythonRobotParser(RobotParser): + def __init__(self, robotstxt_body, spider): + from six.moves.urllib_robotparser import RobotFileParser + self.spider = spider + try: + robotstxt_body = to_native_str(robotstxt_body) + except UnicodeDecodeError: + # If we found garbage or robots.txt in an encoding other than UTF-8, disregard it. + # Switch to 'allow all' state. + logger.warning("Failure while parsing robots.txt using %(parser)s." + " File either contains garbage or is in an encoding other than UTF-8, treating it as an empty file.", + {'parser': "RobotFileParser"}, + exc_info=sys.exc_info(), + extra={'spider': self.spider}) + robotstxt_body = '' + self.rp = RobotFileParser() + self.rp.parse(robotstxt_body.splitlines()) + + @classmethod + def from_crawler(cls, crawler, robotstxt_body): + spider = None if not crawler else crawler.spider + o = cls(robotstxt_body, spider) + return o + + def allowed(self, url, user_agent): + user_agent = to_native_str(user_agent) + url = to_native_str(url) + return self.rp.can_fetch(user_agent, url) + + +class ReppyRobotParser(RobotParser): + def __init__(self, robotstxt_body, spider): + from reppy.robots import Robots + self.spider = spider + self.rp = Robots.parse('', robotstxt_body) + + @classmethod + def from_crawler(cls, crawler, robotstxt_body): + spider = None if not crawler else crawler.spider + o = cls(robotstxt_body, spider) + return o + + def allowed(self, url, user_agent): + return self.rp.allowed(url, user_agent) + + +class RerpRobotParser(RobotParser): + def __init__(self, robotstxt_body, spider): + from robotexclusionrulesparser import RobotExclusionRulesParser + self.spider = spider + self.rp = RobotExclusionRulesParser() + try: + robotstxt_body = robotstxt_body.decode('utf-8') + except UnicodeDecodeError: + # If we found garbage or robots.txt in an encoding other than UTF-8, disregard it. + # Switch to 'allow all' state. + logger.warning("Failure while parsing robots.txt using %(parser)s." + " File either contains garbage or is in an encoding other than UTF-8, treating it as an empty file.", + {'parser': "RobotExclusionRulesParser"}, + exc_info=sys.exc_info(), + extra={'spider': self.spider}) + robotstxt_body = '' + self.rp.parse(robotstxt_body) + + @classmethod + def from_crawler(cls, crawler, robotstxt_body): + spider = None if not crawler else crawler.spider + o = cls(robotstxt_body, spider) + return o + + def allowed(self, url, user_agent): + user_agent = to_unicode(user_agent) + url = to_unicode(url) + return self.rp.is_allowed(user_agent, url) diff --git a/scrapy/settings/default_settings.py b/scrapy/settings/default_settings.py index 9986827d82e..31e92bd712f 100644 --- a/scrapy/settings/default_settings.py +++ b/scrapy/settings/default_settings.py @@ -242,6 +242,7 @@ RETRY_PRIORITY_ADJUST = -1 ROBOTSTXT_OBEY = False +ROBOTSTXT_PARSER = 'scrapy.robotstxt.PythonRobotParser' SCHEDULER = 'scrapy.core.scheduler.Scheduler' SCHEDULER_DISK_QUEUE = 'scrapy.squeues.PickleLifoDiskQueue' diff --git a/tox.ini b/tox.ini index 0c0f8f7b7d5..a9cef9b90d0 100644 --- a/tox.ini +++ b/tox.ini @@ -110,3 +110,17 @@ changedir = {[docs]changedir} deps = {[docs]deps} commands = sphinx-build -W -b linkcheck . {envtmpdir}/linkcheck + +[testenv:py37-extra-deps] +basepython = python3.7 +deps = + {[testenv:py34]deps} + reppy + robotexclusionrulesparser + +[testenv:py27-extra-deps] +basepython = python2.7 +deps = + {[testenv]deps} + reppy + robotexclusionrulesparser	diff --git a/tests/test_downloadermiddleware_robotstxt.py b/tests/test_downloadermiddleware_robotstxt.py index 60306eacb84..816f88ca15c 100644 --- a/tests/test_downloadermiddleware_robotstxt.py +++ b/tests/test_downloadermiddleware_robotstxt.py @@ -11,6 +11,7 @@ from scrapy.http import Request, Response, TextResponse from scrapy.settings import Settings from tests import mock +from tests.test_robotstxt_interface import rerp_available, reppy_available class RobotsTxtMiddlewareTest(unittest.TestCase): @@ -44,6 +45,7 @@ def _get_successful_crawler(self): Disallow: /some/randome/page.html '''.encode('utf-8')) response = TextResponse('http://site.local/robots.txt', body=ROBOTS) + def return_response(request, spider): deferred = Deferred() reactor.callFromThread(deferred.callback, response) @@ -80,6 +82,7 @@ def _get_garbage_crawler(self): crawler = self.crawler crawler.settings.set('ROBOTSTXT_OBEY', True) response = Response('http://site.local/robots.txt', body=b'GIF89a\xd3\x00\xfe\x00\xa2') + def return_response(request, spider): deferred = Deferred() reactor.callFromThread(deferred.callback, response) @@ -102,6 +105,7 @@ def _get_emptybody_crawler(self): crawler = self.crawler crawler.settings.set('ROBOTSTXT_OBEY', True) response = Response('http://site.local/robots.txt') + def return_response(request, spider): deferred = Deferred() reactor.callFromThread(deferred.callback, response) @@ -121,6 +125,7 @@ def test_robotstxt_empty_response(self): def test_robotstxt_error(self): self.crawler.settings.set('ROBOTSTXT_OBEY', True) err = error.DNSLookupError('Robotstxt address not found') + def return_failure(request, spider): deferred = Deferred() reactor.callFromThread(deferred.errback, failure.Failure(err)) @@ -136,6 +141,7 @@ def return_failure(request, spider): def test_robotstxt_immediate_error(self): self.crawler.settings.set('ROBOTSTXT_OBEY', True) err = error.DNSLookupError('Robotstxt address not found') + def immediate_failure(request, spider): deferred = Deferred() deferred.errback(failure.Failure(err)) @@ -147,6 +153,7 @@ def immediate_failure(request, spider): def test_ignore_robotstxt_request(self): self.crawler.settings.set('ROBOTSTXT_OBEY', True) + def ignore_request(request, spider): deferred = Deferred() reactor.callFromThread(deferred.errback, failure.Failure(IgnoreRequest())) @@ -170,3 +177,21 @@ def assertIgnored(self, request, middleware): spider = None # not actually used return self.assertFailure(maybeDeferred(middleware.process_request, request, spider), IgnoreRequest) + + +class RobotsTxtMiddlewareWithRerpTest(RobotsTxtMiddlewareTest): + if not rerp_available(): + skip = "Rerp parser is not installed" + + def setUp(self): + super(RobotsTxtMiddlewareWithRerpTest, self).setUp() + self.crawler.settings.set('ROBOTSTXT_PARSER', 'scrapy.robotstxt.RerpRobotParser') + + +class RobotsTxtMiddlewareWithReppyTest(RobotsTxtMiddlewareTest): + if not reppy_available(): + skip = "Reppy parser is not installed" + + def setUp(self): + super(RobotsTxtMiddlewareWithReppyTest, self).setUp() + self.crawler.settings.set('ROBOTSTXT_PARSER', 'scrapy.robotstxt.ReppyRobotParser') diff --git a/tests/test_robotstxt_interface.py b/tests/test_robotstxt_interface.py new file mode 100644 index 00000000000..2819786b531 --- /dev/null +++ b/tests/test_robotstxt_interface.py @@ -0,0 +1,142 @@ +# coding=utf-8 +from twisted.trial import unittest +from scrapy.utils.python import to_native_str + + +def reppy_available(): + # check if reppy parser is installed + try: + from reppy.robots import Robots + except ImportError: + return False + return True + + +def rerp_available(): + # check if robotexclusionrulesparser is installed + try: + from robotexclusionrulesparser import RobotExclusionRulesParser + except ImportError: + return False + return True + + +class BaseRobotParserTest: + def _setUp(self, parser_cls): + self.parser_cls = parser_cls + + def test_allowed(self): + robotstxt_robotstxt_body = ("User-agent: * \n" + "Disallow: /disallowed \n" + "Allow: /allowed \n" + "Crawl-delay: 10".encode('utf-8')) + rp = self.parser_cls.from_crawler(crawler=None, robotstxt_body=robotstxt_robotstxt_body) + self.assertTrue(rp.allowed("https://www.site.local/allowed", "")) + self.assertFalse(rp.allowed("https://www.site.local/disallowed", "")) + + def test_allowed_wildcards(self): + robotstxt_robotstxt_body = """User-agent: first + Disallow: /disallowed//end$ + + User-agent: second + Allow: /allowed + Disallow: / + """.encode('utf-8') + rp = self.parser_cls.from_crawler(crawler=None, robotstxt_body=robotstxt_robotstxt_body) + + self.assertTrue(rp.allowed("https://www.site.local/disallowed", "first")) + self.assertFalse(rp.allowed("https://www.site.local/disallowed/xyz/end", "first")) + self.assertFalse(rp.allowed("https://www.site.local/disallowed/abc/end", "first")) + self.assertTrue(rp.allowed("https://www.site.local/disallowed/xyz/endinglater", "first")) + + self.assertTrue(rp.allowed("https://www.site.local/allowed", "second")) + self.assertTrue(rp.allowed("https://www.site.local/is_still_allowed", "second")) + self.assertTrue(rp.allowed("https://www.site.local/is_allowed_too", "second")) + + def test_length_based_precedence(self): + robotstxt_robotstxt_body = ("User-agent: * \n" + "Disallow: / \n" + "Allow: /page".encode('utf-8')) + rp = self.parser_cls.from_crawler(crawler=None, robotstxt_body=robotstxt_robotstxt_body) + self.assertTrue(rp.allowed("https://www.site.local/page", "")) + + def test_order_based_precedence(self): + robotstxt_robotstxt_body = ("User-agent: \n" + "Disallow: / \n" + "Allow: /page".encode('utf-8')) + rp = self.parser_cls.from_crawler(crawler=None, robotstxt_body=robotstxt_robotstxt_body) + self.assertFalse(rp.allowed("https://www.site.local/page", "")) + + def test_empty_response(self): + """empty response should equal 'allow all'""" + rp = self.parser_cls.from_crawler(crawler=None, robotstxt_body=b'') + self.assertTrue(rp.allowed("https://site.local/", "")) + self.assertTrue(rp.allowed("https://site.local/", "chrome")) + self.assertTrue(rp.allowed("https://site.local/index.html", "")) + self.assertTrue(rp.allowed("https://site.local/disallowed", "")) + + def test_garbage_response(self): + """garbage response should be discarded, equal 'allow all'""" + robotstxt_robotstxt_body = b'GIF89a\xd3\x00\xfe\x00\xa2' + rp = self.parser_cls.from_crawler(crawler=None, robotstxt_body=robotstxt_robotstxt_body) + self.assertTrue(rp.allowed("https://site.local/", "")) + self.assertTrue(rp.allowed("https://site.local/", "chrome")) + self.assertTrue(rp.allowed("https://site.local/index.html", "")) + self.assertTrue(rp.allowed("https://site.local/disallowed", "")) + + def test_unicode_url_and_useragent(self): + robotstxt_robotstxt_body = u""" + User-Agent: + Disallow: /admin/ + Disallow: /static/ + # taken from https://en.wikipedia.org/robots.txt + Disallow: /wiki/K%C3%A4ytt%C3%A4j%C3%A4: + Disallow: /wiki/Käyttäjä: + + User-Agent: UnicödeBöt + Disallow: /some/randome/page.html""".encode('utf-8') + rp = self.parser_cls.from_crawler(crawler=None, robotstxt_body=robotstxt_robotstxt_body) + self.assertTrue(rp.allowed("https://site.local/", "")) + self.assertFalse(rp.allowed("https://site.local/admin/", "")) + self.assertFalse(rp.allowed("https://site.local/static/", "")) + self.assertTrue(rp.allowed("https://site.local/admin/", u"UnicödeBöt")) + self.assertFalse(rp.allowed("https://site.local/wiki/K%C3%A4ytt%C3%A4j%C3%A4:", "")) + self.assertFalse(rp.allowed(u"https://site.local/wiki/Käyttäjä:", "")) + self.assertTrue(rp.allowed("https://site.local/some/randome/page.html", "")) + self.assertFalse(rp.allowed("https://site.local/some/randome/page.html", u"UnicödeBöt")) + + +class PythonRobotParserTest(BaseRobotParserTest, unittest.TestCase): + def setUp(self): + from scrapy.robotstxt import PythonRobotParser + super(PythonRobotParserTest, self)._setUp(PythonRobotParser) + + def test_length_based_precedence(self): + raise unittest.SkipTest("RobotFileParser does not support length based directives precedence.") + + def test_allowed_wildcards(self): + raise unittest.SkipTest("RobotFileParser does not support wildcards.") + + +class ReppyRobotParserTest(BaseRobotParserTest, unittest.TestCase): + if not reppy_available(): + skip = "Reppy parser is not installed" + + def setUp(self): + from scrapy.robotstxt import ReppyRobotParser + super(ReppyRobotParserTest, self)._setUp(ReppyRobotParser) + + def test_order_based_precedence(self): + raise unittest.SkipTest("Rerp does not support order based directives precedence.") + + +class RerpRobotParserTest(BaseRobotParserTest, unittest.TestCase): + if not rerp_available(): + skip = "Rerp parser is not installed" + + def setUp(self): + from scrapy.robotstxt import RerpRobotParser + super(RerpRobotParserTest, self)._setUp(RerpRobotParser) + + def test_length_based_precedence(self): + raise unittest.SkipTest("Rerp does not support length based directives precedence.")	diff --git a/.travis.yml b/.travis.yml index 08b0bf1195c..dc333a2012d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -26,6 +26,12 @@ matrix: sudo: true - python: 3.6 env: TOXENV=docs + - python: 3.7 + env: TOXENV=py37-extra-deps + dist: xenial + sudo: true + - python: 2.7 + env: TOXENV=py27-extra-deps install: - \| if [ "$TOXENV" = "pypy" ]; then diff --git a/docs/topics/downloader-middleware.rst b/docs/topics/downloader-middleware.rst index f2f3ef46657..ae1086ee10e 100644 --- a/docs/topics/downloader-middleware.rst +++ b/docs/topics/downloader-middleware.rst @@ -922,6 +922,17 @@ RobotsTxtMiddleware To make sure Scrapy respects robots.txt make sure the middleware is enabled and the :setting:`ROBOTSTXT_OBEY` setting is enabled. + This middleware has to be combined with a robots.txt_ parser. + + Scrapy ships with support for the following robots.txt_ parsers: + + * :ref:`RobotFileParser <python-robotfileparser>` (default) + * :ref:`Reppy <reppy-parser>` + * :ref:`Robotexclusionrulesparser <rerp-parser>` + + You can change the robots.txt_ parser with the :setting:`ROBOTSTXT_PARSER` + setting. Or you can also :ref:`implement support for a new parser <support-for-new-robots-parser>`. + .. reqmeta:: dont_obey_robotstxt If :attr:`Request.meta <scrapy.http.Request.meta>` has @@ -929,6 +940,74 @@ If :attr:`Request.meta <scrapy.http.Request.meta>` has the request will be ignored by this middleware even if :setting:`ROBOTSTXT_OBEY` is enabled. +.. _python-robotfileparser: + +RobotFileParser +~~~~~~~~~~~~~~~ + +`RobotFileParser <https://docs.python.org/3.7/library/urllib.robotparser.html>`_ is +Python's inbuilt ``robots.txt`` parser. The parser is fully compliant with `Martijn Koster's +1996 draft specification <http://www.robotstxt.org/norobots-rfc.txt>`_. It lacks +support for wildcard matching. Scrapy uses this parser by default. + +In order to use this parser, set: + +* :setting:`ROBOTSTXT_PARSER` to ``scrapy.robotstxt.PythonRobotParser`` + +.. _rerp-parser: + +Robotexclusionrulesparser +~~~~~~~~~~~~~~~~~~~~~~~~~ + +`Robotexclusionrulesparser <http://nikitathespider.com/python/rerp/>`_ is fully compliant +with `Martijn Koster's 1996 draft specification <http://www.robotstxt.org/norobots-rfc.txt>`_, +with support for wildcard matching. + +In order to use this parser: + +* Install `Robotexclusionrulesparser <http://nikitathespider.com/python/rerp/>`_ by running + ``pip install robotexclusionrulesparser`` + +* Set :setting:`ROBOTSTXT_PARSER` setting to + ``scrapy.robotstxt.RerpRobotParser`` + +.. _reppy-parser: + +Reppy parser +~~~~~~~~~~~~ + +`Reppy <https://github.com/seomoz/reppy/>`_ is a Python wrapper around `Robots Exclusion +Protocol Parser for C++ <https://github.com/seomoz/rep-cpp>`_. The parser is fully compliant +with `Martijn Koster's 1996 draft specification <http://www.robotstxt.org/norobots-rfc.txt>`_, +with support for wildcard matching. Unlike +`RobotFileParser <https://docs.python.org/3.7/library/urllib.robotparser.html>`_ and +`Robotexclusionrulesparser <http://nikitathespider.com/python/rerp/>`_, it uses the length based +rule, in particular for ``Allow`` and ``Disallow`` directives, where the most specific +rule based on the length of the path trumps the less specific (shorter) rule. + +In order to use this parser: + +* Install `Reppy <https://github.com/seomoz/reppy/>`_ by running ``pip install reppy`` + +* Set :setting:`ROBOTSTXT_PARSER` setting to + ``scrapy.robotstxt.ReppyRobotParser`` + +.. _support-for-new-robots-parser: + +Implementing support for a new parser +------------------------------------- + +You can implement support for a new robots.txt_ parser by subclassing +the abstract base class :class:`~scrapy.robotstxt.RobotParser` and +implementing the methods described below. + +.. module:: scrapy.robotstxt + :synopsis: robots.txt parser interface and implementations + +.. autoclass:: RobotParser + :members: + +.. _robots.txt: http://www.robotstxt.org/ DownloaderStats --------------- diff --git a/docs/topics/settings.rst b/docs/topics/settings.rst index 371f21c72f5..0d3eaa094c8 100644 --- a/docs/topics/settings.rst +++ b/docs/topics/settings.rst @@ -1113,6 +1113,16 @@ If enabled, Scrapy will respect robots.txt policies. For more information see this option is enabled by default in settings.py file generated by ``scrapy startproject`` command. +.. setting:: ROBOTSTXT_PARSER + +ROBOTSTXT_PARSER +---------------- + +Default: ``'scrapy.robotstxt.PythonRobotParser'`` + +The parser backend to use for parsing ``robots.txt`` files. For more information see +:ref:`topics-dlmw-robots`. + .. setting:: SCHEDULER SCHEDULER diff --git a/tox.ini b/tox.ini index 0c0f8f7b7d5..a9cef9b90d0 100644 --- a/tox.ini +++ b/tox.ini @@ -110,3 +110,17 @@ changedir = {[docs]changedir} deps = {[docs]deps} commands = sphinx-build -W -b linkcheck . {envtmpdir}/linkcheck + +[testenv:py37-extra-deps] +basepython = python3.7 +deps = + {[testenv:py34]deps} + reppy + robotexclusionrulesparser + +[testenv:py27-extra-deps] +basepython = python2.7 +deps = + {[testenv]deps} + reppy + robotexclusionrulesparser	[ { "components": [ { "doc": "", "lines": [ 11, 36 ], "name": "RobotParser", "signature": "class RobotParser(with_metaclass(ABCMeta)): @classmethod @abstractmethod", "type": "class" }, { "doc": "Parse the content of a ro...	[ "tests/test_robotstxt_interface.py::PythonRobotParserTest::test_allowed", "tests/test_robotstxt_interface.py::PythonRobotParserTest::test_empty_response", "tests/test_robotstxt_interface.py::PythonRobotParserTest::test_garbage_response", "tests/test_robotstxt_interface.py::PythonRobotParserTest::test_order_ba...	[ "tests/test_downloadermiddleware_robotstxt.py::RobotsTxtMiddlewareTest::test_ignore_robotstxt_request", "tests/test_downloadermiddleware_robotstxt.py::RobotsTxtMiddlewareTest::test_robotstxt", "tests/test_downloadermiddleware_robotstxt.py::RobotsTxtMiddlewareTest::test_robotstxt_empty_response", "tests/test_d...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG+1] [GSoC 2019] Interface for robots.txt parsers [For Google Summer of Code 2019] This pull request is not ready for merging. Looking for reviews and suggestions. Excited for the awesome summer ahead. :) @Gallaecio @whalebot-helmsman Will there be any benefit from using python's abc library for creating `BaseRobotsTxtParser` class here? ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in scrapy/robotstxt.py] (definition of RobotParser:) class RobotParser(with_metaclass(ABCMeta)): @classmethod @abstractmethod (definition of RobotParser.from_crawler:) def from_crawler(cls, crawler, robotstxt_body): """Parse the content of a robots.txt_ file as bytes. This must be a class method. It must return a new instance of the parser backend. :param crawler: crawler which made the request :type crawler: :class:`~scrapy.crawler.Crawler` instance :param robotstxt_body: content of a robots.txt_ file. :type robotstxt_body: bytes""" (definition of RobotParser.allowed:) def allowed(self, url, user_agent): """Return ``True`` if ``user_agent`` is allowed to crawl ``url``, otherwise return ``False``. :param url: Absolute URL :type url: string :param user_agent: User agent :type user_agent: string""" (definition of PythonRobotParser:) class PythonRobotParser(RobotParser): (definition of PythonRobotParser.__init__:) def __init__(self, robotstxt_body, spider): (definition of PythonRobotParser.from_crawler:) def from_crawler(cls, crawler, robotstxt_body): (definition of PythonRobotParser.allowed:) def allowed(self, url, user_agent): (definition of ReppyRobotParser:) class ReppyRobotParser(RobotParser): (definition of ReppyRobotParser.__init__:) def __init__(self, robotstxt_body, spider): (definition of ReppyRobotParser.from_crawler:) def from_crawler(cls, crawler, robotstxt_body): (definition of ReppyRobotParser.allowed:) def allowed(self, url, user_agent): (definition of RerpRobotParser:) class RerpRobotParser(RobotParser): (definition of RerpRobotParser.__init__:) def __init__(self, robotstxt_body, spider): (definition of RerpRobotParser.from_crawler:) def from_crawler(cls, crawler, robotstxt_body): (definition of RerpRobotParser.allowed:) def allowed(self, url, user_agent): [end of new definitions in scrapy/robotstxt.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		57a5460529ff71c42e4d0381265b1b512b1eb09b
sympy__sympy-16896	16,896	sympy/sympy	1.5	8e23c8091c4c60a4479a23c78bac1ee535adbcdc	2019-05-26T12:56:25Z	diff --git a/sympy/calculus/util.py b/sympy/calculus/util.py index 4c8a2559d051..90fce092429f 100644 --- a/sympy/calculus/util.py +++ b/sympy/calculus/util.py @@ -280,8 +280,8 @@ def not_empty_in(finset_intersection, syms): if len(syms) == 0: raise ValueError("One or more symbols must be given in syms.") - if finset_intersection.is_EmptySet: - return EmptySet() + if finset_intersection is S.EmptySet: + return S.EmptySet if isinstance(finset_intersection, Union): elm_in_sets = finset_intersection.args[0] diff --git a/sympy/core/function.py b/sympy/core/function.py index 2ddee5df54fa..7399654f14d8 100644 --- a/sympy/core/function.py +++ b/sympy/core/function.py @@ -1864,6 +1864,9 @@ def __new__(cls, variables, expr): for i in v: if not getattr(i, 'is_symbol', False): raise TypeError('variable is not a symbol: %s' % i) + if len(v) != len(set(v)): + x = [i for i in v if v.count(i) > 1][0] + raise SyntaxError("duplicate argument '%s' in Lambda args" % x) if len(v) == 1 and v[0] == expr: return S.IdentityFunction diff --git a/sympy/ntheory/continued_fraction.py b/sympy/ntheory/continued_fraction.py index 1c38d3bf2423..848f30e9c09d 100644 --- a/sympy/ntheory/continued_fraction.py +++ b/sympy/ntheory/continued_fraction.py @@ -171,8 +171,8 @@ def continued_fraction_periodic(p, q, d=0, s=1): if (d - p2)%q: d = q*2 sd = q - p = abs(q) - q = abs(q) + p = q + q = q terms = [] pq = {} diff --git a/sympy/printing/pretty/pretty.py b/sympy/printing/pretty/pretty.py index e070adf3acb1..d67ff0b19982 100644 --- a/sympy/printing/pretty/pretty.py +++ b/sympy/printing/pretty/pretty.py @@ -163,6 +163,7 @@ def _print_Atom(self, e): _print_Naturals = _print_Atom _print_Naturals0 = _print_Atom _print_Integers = _print_Atom + _print_Rationals = _print_Atom _print_Complexes = _print_Atom def _print_Reals(self, e): diff --git a/sympy/printing/pretty/pretty_symbology.py b/sympy/printing/pretty/pretty_symbology.py index d27eb51653e4..348a59bcf7f3 100644 --- a/sympy/printing/pretty/pretty_symbology.py +++ b/sympy/printing/pretty/pretty_symbology.py @@ -501,6 +501,7 @@ def xsym(sym): (U('DOUBLE-STRUCK CAPITAL N') + U('SUBSCRIPT ZERO'))), 'Integers': U('DOUBLE-STRUCK CAPITAL Z'), + 'Rationals': U('DOUBLE-STRUCK CAPITAL Q'), 'Reals': U('DOUBLE-STRUCK CAPITAL R'), 'Complexes': U('DOUBLE-STRUCK CAPITAL C'), 'Union': U('UNION'), diff --git a/sympy/printing/str.py b/sympy/printing/str.py index ee560ca0a822..0ce283b18bed 100644 --- a/sympy/printing/str.py +++ b/sympy/printing/str.py @@ -582,6 +582,9 @@ def _print_Naturals(self, expr): def _print_Naturals0(self, expr): return 'Naturals0' + def _print_Rationals(self, expr): + return 'Rationals' + def _print_Reals(self, expr): return 'Reals' diff --git a/sympy/sets/__init__.py b/sympy/sets/__init__.py index 453fc449e9d2..a66ce07138aa 100644 --- a/sympy/sets/__init__.py +++ b/sympy/sets/__init__.py @@ -10,4 +10,5 @@ Naturals0 = S.Naturals0 UniversalSet = S.UniversalSet Integers = S.Integers +Rationals = S.Rationals del S diff --git a/sympy/sets/conditionset.py b/sympy/sets/conditionset.py index 3a4f3a8282ce..6437f471a84a 100644 --- a/sympy/sets/conditionset.py +++ b/sympy/sets/conditionset.py @@ -175,7 +175,15 @@ def free_symbols(self): s, c, b = self.args return (c.free_symbols - s.free_symbols) \| b.free_symbols - def contains(self, other): + def _contains(self, other): + d = Dummy() + try: + return self.as_relational(d).subs(d, other) + except TypeError: + # couldn't do the substitution without error + return False + + def as_relational(self, other): return And(Lambda(self.sym, self.condition)( other), self.base_set.contains(other)) diff --git a/sympy/sets/fancysets.py b/sympy/sets/fancysets.py index 3da73cf4602f..0d4804359b10 100644 --- a/sympy/sets/fancysets.py +++ b/sympy/sets/fancysets.py @@ -4,14 +4,67 @@ from sympy.core.compatibility import as_int, with_metaclass, range, PY3 from sympy.core.expr import Expr from sympy.core.function import Lambda +from sympy.core.numbers import oo +from sympy.core.relational import Eq from sympy.core.singleton import Singleton, S from sympy.core.symbol import Dummy, symbols from sympy.core.sympify import _sympify, sympify, converter from sympy.logic.boolalg import And -from sympy.sets.sets import Set, Interval, Union, FiniteSet, ProductSet +from sympy.sets.sets import (Set, Interval, Union, FiniteSet, + ProductSet, Intersection) +from sympy.sets.contains import Contains +from sympy.sets.conditionset import ConditionSet +from sympy.utilities.iterables import flatten from sympy.utilities.misc import filldedent +class Rationals(with_metaclass(Singleton, Set)): + """ + Represents the rational numbers. This set is also available as + the Singleton, S.Rationals. + + Examples + ======== + + >>> from sympy import S + >>> S.Half in S.Rationals + True + >>> iterable = iter(S.Rationals) + >>> [next(iterable) for i in range(12)] + [0, 1, -1, 1/2, 2, -1/2, -2, 1/3, 3, -1/3, -3, 2/3] + """ + + is_iterable = True + _inf = S.NegativeInfinity + _sup = S.Infinity + + def _contains(self, other): + if not isinstance(other, Expr): + return False + if other.is_Number: + return other.is_Rational + return other.is_rational + + def __iter__(self): + from sympy.core.numbers import igcd, Rational + yield S.Zero + yield S.One + yield S.NegativeOne + d = 2 + while True: + for n in range(d): + if igcd(n, d) == 1: + yield Rational(n, d) + yield Rational(d, n) + yield Rational(-n, d) + yield Rational(-d, n) + d += 1 + + @property + def _boundary(self): + return self + + class Naturals(with_metaclass(Singleton, Set)): """ Represents the natural numbers (or counting numbers) which are all @@ -47,11 +100,11 @@ class Naturals(with_metaclass(Singleton, Set)): def _contains(self, other): if not isinstance(other, Expr): - return S.false + return False elif other.is_positive and other.is_integer: - return S.true + return True elif other.is_integer is False or other.is_positive is False: - return S.false + return False def __iter__(self): i = self._inf @@ -63,6 +116,10 @@ def __iter__(self): def _boundary(self): return self + def as_relational(self, x): + from sympy.functions.elementary.integers import floor + return And(Eq(floor(x), x), x >= self.inf, x < oo) + class Naturals0(Naturals): """Represents the whole numbers which are all the non-negative integers, @@ -121,10 +178,7 @@ class Integers(with_metaclass(Singleton, Set)): def _contains(self, other): if not isinstance(other, Expr): return S.false - elif other.is_integer: - return S.true - elif other.is_integer is False: - return S.false + return other.is_integer def __iter__(self): yield S.Zero @@ -146,6 +200,10 @@ def _sup(self): def _boundary(self): return self + def as_relational(self, x): + from sympy.functions.elementary.integers import floor + return And(Eq(floor(x), x), -oo < x, x < oo) + class Reals(with_metaclass(Singleton, Interval)): """ @@ -246,9 +304,13 @@ class ImageSet(Set): def __new__(cls, flambda, sets): if not isinstance(flambda, Lambda): raise ValueError('first argument must be a Lambda') - if flambda is S.IdentityFunction and len(sets) == 1: + + if flambda is S.IdentityFunction: + if len(sets) != 1: + raise ValueError('identify function requires a single set') return sets[0] - if not flambda.expr.free_symbols or not flambda.expr.args: + + if not set(flambda.variables) & flambda.expr.free_symbols: return FiniteSet(flambda.expr) return Basic.__new__(cls, flambda, sets) @@ -275,17 +337,11 @@ def _contains(self, other): from sympy.solvers.solvers import solve from sympy.utilities.iterables import is_sequence, iterable, cartes L = self.lamda - if is_sequence(other): - if not is_sequence(L.expr): - return S.false - if len(L.expr) != len(other): - raise ValueError(filldedent(''' - Dimensions of other and output of Lambda are different.''')) - elif iterable(other): - raise ValueError(filldedent(''' - `other` should be an ordered object like a Tuple.''')) + if is_sequence(other) != is_sequence(L.expr): + return False + elif is_sequence(other) and len(L.expr) != len(other): + return False - solns = None if self._is_multivariate(): if not is_sequence(L.expr): # exprs -> (numer, denom) and check again @@ -333,6 +389,12 @@ def _contains(self, other): # for x, y and getting (x, 0), (0, y), (0, 0) solns = [i for i in solns if not any( s in i for s in variables)] + if not solns: + return False + else: + # not sure if [] means no solution or + # couldn't find one + return else: x = L.variables[0] if isinstance(L.expr, Expr): @@ -344,31 +406,29 @@ def _contains(self, other): msgset = solnsSet else: # scalar -> vector + # note: it is not necessary for components of other + # to be in the corresponding base set unless the + # computed component is always in the corresponding + # domain. e.g. 1/2 is in imageset(x, x/2, Integers) + # while it cannot be in imageset(x, x + 2, Integers). + # So when the base set is comprised of integers or reals + # perhaps a pre-check could be done to see if the computed + # values are still in the set. + dom = self.base_set for e, o in zip(L.expr, other): - solns = solveset(e - o, x) - if solns is S.EmptySet: - return S.false - for soln in solns: - try: - if soln in self.base_set: - break # check next pair - except TypeError: - if self.base_set.contains(soln.evalf()): - break - else: - return S.false # never broke so there was no True - return S.true - - if solns is None: - raise NotImplementedError(filldedent(''' - Determining whether %s contains %s has not - been implemented.''' % (msgset, other))) + msgset = dom + other = e - o + dom = dom.intersection(solveset(e - o, x, domain=dom)) + if not dom: + # there is no solution in common + return False + return not isinstance(dom, Intersection) for soln in solns: try: if soln in self.base_set: - return S.true + return True except TypeError: - return self.base_set.contains(soln.evalf()) + return return S.false @property @@ -913,7 +973,6 @@ def __new__(cls, sets, polar=False): new_sets.append(sets) # Normalize input theta for k, v in enumerate(new_sets): - from sympy.sets import ProductSet new_sets[k] = ProductSet(v.args[0], normalize_theta_set(v.args[1])) sets = Union(new_sets) diff --git a/sympy/sets/handlers/functions.py b/sympy/sets/handlers/functions.py index d811e87b6dd8..c4b6423c62cb 100644 --- a/sympy/sets/handlers/functions.py +++ b/sympy/sets/handlers/functions.py @@ -1,4 +1,4 @@ -from sympy import Set, symbols, exp, log, S, Wild +from sympy import Set, symbols, exp, log, S, Wild, Dummy, oo from sympy.core import Expr, Add from sympy.core.function import Lambda, _coeff_isneg, FunctionClass from sympy.core.mod import Mod @@ -6,7 +6,7 @@ from sympy.multipledispatch import dispatch from sympy.sets import (imageset, Interval, FiniteSet, Union, ImageSet, EmptySet, Intersection, Range) -from sympy.sets.fancysets import Integers, Naturals +from sympy.sets.fancysets import Integers, Naturals, Reals _x, _y = symbols("x y") @@ -37,6 +37,9 @@ def _set_function(f, x): if len(expr.free_symbols) > 1 or len(f.variables) != 1: return var = f.variables[0] + if not var.is_real: + if expr.subs(var, Dummy(real=True)).is_real is False: + return if expr.is_Piecewise: result = S.EmptySet @@ -56,7 +59,7 @@ def _set_function(f, x): # remove the part which has been `imaged` domain_set = Complement(domain_set, intrvl) - if domain_set.is_EmptySet: + if domain_set is S.EmptySet: break return result @@ -169,6 +172,8 @@ def _set_function(f, self): return n = f.variables[0] + if expr == abs(n): + return S.Naturals0 # f(x) + c and f(-x) + c cover the same integers # so choose the form that has the fewest negatives @@ -212,11 +217,28 @@ def _set_function(f, self): x = f.variables[0] if not expr.free_symbols - {x}: + if expr == abs(x): + if self is S.Naturals: + return self + return S.Naturals0 step = expr.coeff(x) c = expr.subs(x, 0) if c.is_Integer and step.is_Integer and expr == stepx + c: if self is S.Naturals: c += step if step > 0: - return Range(c, S.Infinity, step) - return Range(c, S.NegativeInfinity, step) + if step == 1: + if c == 0: + return S.Naturals0 + elif c == 1: + return S.Naturals + return Range(c, oo, step) + return Range(c, -oo, step) + + +@dispatch(FunctionUnion, Reals) +def _set_function(f, self): + expr = f.expr + if not isinstance(expr, Expr): + return + return _set_function(f, Interval(-oo, oo)) diff --git a/sympy/sets/handlers/intersection.py b/sympy/sets/handlers/intersection.py index 34b9a94cf6e3..ea4108fae38a 100644 --- a/sympy/sets/handlers/intersection.py +++ b/sympy/sets/handlers/intersection.py @@ -3,7 +3,7 @@ from sympy.multipledispatch import dispatch from sympy.sets.conditionset import ConditionSet from sympy.sets.fancysets import (Integers, Naturals, Reals, Range, - ImageSet, Naturals0) + ImageSet, Naturals0, Rationals) from sympy.sets.sets import UniversalSet, imageset, ProductSet @@ -25,27 +25,12 @@ def intersection_sets(a, b): @dispatch(Naturals, Naturals) def intersection_sets(a, b): - return a if a is S.Naturals0 else b - -@dispatch(Naturals, Interval) -def intersection_sets(a, b): - return Intersection(S.Integers, b, Interval(a._inf, S.Infinity)) + return a if a is S.Naturals else b @dispatch(Interval, Naturals) def intersection_sets(a, b): return intersection_sets(b, a) -@dispatch(Integers, Interval) -def intersection_sets(a, b): - try: - from sympy.functions.elementary.integers import floor, ceiling - if b._inf is S.NegativeInfinity and b._sup is S.Infinity: - return a - s = Range(ceiling(b.left), floor(b.right) + 1) - return intersection_sets(s, b) # take out endpoints if open interval - except ValueError: - return None - @dispatch(ComplexRegion, Set) def intersection_sets(self, other): if other.is_ComplexRegion: @@ -157,7 +142,7 @@ def intersection_sets(a, b): # we want to know when the two equations might # have integer solutions so we use the diophantine # solver - va, vb = diop_linear(eq(r1, Dummy()) - eq(r2, Dummy())) + va, vb = diop_linear(eq(r1, Dummy('a')) - eq(r2, Dummy('b'))) # check for no solution no_solution = va is None and vb is None @@ -446,3 +431,33 @@ def intersection_sets(a, b): @dispatch(Set, Set) def intersection_sets(a, b): return None + +@dispatch(Integers, Rationals) +def intersection_sets(a, b): + return a + +@dispatch(Naturals, Rationals) +def intersection_sets(a, b): + return a + +@dispatch(Rationals, Reals) +def intersection_sets(a, b): + return a + +def _intlike_interval(a, b): + try: + from sympy.functions.elementary.integers import floor, ceiling + if b._inf is S.NegativeInfinity and b._sup is S.Infinity: + return a + s = Range(max(a.inf, ceiling(b.left)), floor(b.right) + 1) + return intersection_sets(s, b) # take out endpoints if open interval + except ValueError: + return None + +@dispatch(Integers, Interval) +def intersection_sets(a, b): + return _intlike_interval(a, b) + +@dispatch(Naturals, Interval) +def intersection_sets(a, b): + return _intlike_interval(a, b) diff --git a/sympy/sets/sets.py b/sympy/sets/sets.py index b85427e79332..03cf57a30bd8 100644 --- a/sympy/sets/sets.py +++ b/sympy/sets/sets.py @@ -1,17 +1,18 @@ from __future__ import print_function, division from itertools import product +from collections import defaultdict import inspect from sympy.core.basic import Basic from sympy.core.compatibility import (iterable, with_metaclass, - ordered, range, PY3) + ordered, range, PY3, is_sequence) from sympy.core.cache import cacheit from sympy.core.evalf import EvalfMixin from sympy.core.evaluate import global_evaluate from sympy.core.expr import Expr from sympy.core.function import FunctionClass -from sympy.core.logic import fuzzy_bool +from sympy.core.logic import fuzzy_bool, fuzzy_or from sympy.core.mul import Mul from sympy.core.numbers import Float from sympy.core.operations import LatticeOp @@ -27,6 +28,13 @@ from mpmath import mpi, mpf + +tfn = defaultdict(lambda: None, { + True: S.true, + S.true: S.true, + False: S.false, + S.false: S.false}) + class Set(Basic): """ The base class for any kind of set. @@ -270,28 +278,57 @@ def _sup(self): def contains(self, other): """ - Returns True if 'other' is contained in 'self' as an element. - - As a shortcut it is possible to use the 'in' operator: + Returns a SymPy value indicating whether ``other`` is contained + in ``self``: ``true`` if it is, ``false`` if it isn't, else + an unevaluated ``Contains`` expression (or, as in the case of + ConditionSet and a union of FiniteSet/Intervals, an expression + indicating the conditions for containment). Examples ======== - >>> from sympy import Interval + >>> from sympy import Interval, S + >>> from sympy.abc import x + >>> Interval(0, 1).contains(0.5) True - >>> 0.5 in Interval(0, 1) - True + As a shortcut it is possible to use the 'in' operator, but that + will raise an error unless an affirmative true or false is not + obtained. + + >>> Interval(0, 1).contains(x) + (0 <= x) & (x <= 1) + >>> x in Interval(0, 1) + Traceback (most recent call last): + ... + TypeError: did not evaluate to a bool: None + + The result of 'in' is a bool, not a SymPy value + + >>> 1 in Interval(0, 2) + True + >>> _ is S.true + False """ other = sympify(other, strict=True) - ret = sympify(self._contains(other)) - if ret is None: - ret = Contains(other, self, evaluate=False) - return ret + c = self._contains(other) + if c is None: + return Contains(other, self, evaluate=False) + b = tfn[c] + if b is None: + return c + return b def _contains(self, other): - raise NotImplementedError("(%s)._contains(%s)" % (self, other)) + raise NotImplementedError(filldedent(''' + (%s)._contains(%s) is not defined. This method, when + defined, will receive a sympified object. The method + should return True, False, None or something that + expresses what must be true for the containment of that + object in self to be evaluated. If None is returned + then a generic Contains object will be returned + by the ``contains`` method.''' % (self, other))) def is_subset(self, other): """ @@ -308,10 +345,12 @@ def is_subset(self, other): """ if isinstance(other, Set): - # XXX issue 16873 - # self might be an unevaluated form of self - # so the equality test will fail - return self.intersect(other) == self + s_o = self.intersect(other) + if s_o == self: + return True + elif not isinstance(other, Intersection): + return False + return s_o else: raise ValueError("Unknown argument '%s'" % other) @@ -556,10 +595,12 @@ def __sub__(self, other): return Complement(self, other) def __contains__(self, other): - symb = sympify(self.contains(other)) - if not (symb is S.true or symb is S.false): - raise TypeError('contains did not evaluate to a bool: %r' % symb) - return bool(symb) + other = sympify(other) + c = self._contains(other) + b = tfn[c] + if b is None: + raise TypeError('did not evaluate to a bool: %r' % c) + return b class ProductSet(Set): @@ -648,13 +689,21 @@ def _contains(self, element): Passes operation on to constituent sets """ - try: + if is_sequence(element): if len(element) != len(self.args): - return false - except TypeError: # maybe element isn't an iterable - return false - return And(* - [set.contains(item) for set, item in zip(self.sets, element)]) + return False + elif len(self.args) > 1: + return False + d = [Dummy() for i in element] + reps = dict(zip(d, element)) + return tfn[self.as_relational(d).xreplace(reps)] + + def as_relational(self, symbols): + if len(symbols) != len(self.args) or not all( + i.is_Symbol for i in symbols): + raise ValueError( + 'number of symbols must match the number of sets') + return And([s.contains(i) for s, i in zip(self.args, symbols)]) @property def sets(self): @@ -915,17 +964,21 @@ def _contains(self, other): if not other.is_extended_real is None: return other.is_extended_real - if self.left_open: - expr = other > self.start - else: - expr = other >= self.start + d = Dummy() + return self.as_relational(d).subs(d, other) + def as_relational(self, x): + """Rewrite an interval in terms of inequalities and logic operators.""" + x = sympify(x) if self.right_open: - expr = And(expr, other < self.end) + right = x < self.end else: - expr = And(expr, other <= self.end) - - return _sympify(expr) + right = x <= self.end + if self.left_open: + left = self.start < x + else: + left = self.start <= x + return And(left, right) @property def _measure(self): @@ -958,19 +1011,6 @@ def is_right_unbounded(self): """Return ``True`` if the right endpoint is positive infinity. """ return self.right is S.Infinity or self.right == Float("+inf") - def as_relational(self, x): - """Rewrite an interval in terms of inequalities and logic operators.""" - x = sympify(x) - if self.right_open: - right = x < self.end - else: - right = x <= self.end - if self.left_open: - left = self.start < x - else: - left = self.start <= x - return And(left, right) - def _eval_Eq(self, other): if not isinstance(other, Interval): if isinstance(other, FiniteSet): @@ -1062,9 +1102,6 @@ def _sup(self): from sympy.functions.elementary.miscellaneous import Max return Max([set.sup for set in self.args]) - def _contains(self, other): - return Or([set.contains(other) for set in self.args]) - @property def _measure(self): # Measure of a union is the sum of the measures of the sets minus @@ -1120,14 +1157,28 @@ def boundary_of_set(i): return b return Union(map(boundary_of_set, range(len(self.args)))) + def _contains(self, other): + try: + d = Dummy() + r = self.as_relational(d).subs(d, other) + b = tfn[r] + if b is None and not any(isinstance(i.contains(other), Contains) + for i in self.args): + return r + return b + except (TypeError, NotImplementedError): + return Or([s.contains(other) for s in self.args]) + def as_relational(self, symbol): """Rewrite a Union in terms of equalities and logic operators. """ - if len(self.args) == 2: - a, b = self.args - if (a.sup == b.inf and a.inf is S.NegativeInfinity - and b.sup is S.Infinity): - return And(Ne(symbol, a.sup), symbol < b.sup, symbol > a.inf) - return Or([set.as_relational(symbol) for set in self.args]) + if all(isinstance(i, (FiniteSet, Interval)) for i in self.args): + if len(self.args) == 2: + a, b = self.args + if (a.sup == b.inf and a.inf is S.NegativeInfinity + and b.sup is S.Infinity): + return And(Ne(symbol, a.sup), symbol < b.sup, symbol > a.inf) + return Or([set.as_relational(symbol) for set in self.args]) + raise NotImplementedError('relational of Union with non-Intervals') @property def is_iterable(self): @@ -1613,16 +1664,9 @@ def _contains(self, other): False """ - r = false - for e in self.args: - # override global evaluation so we can use Eq to do - # do the evaluation - t = Eq(e, other, evaluate=True) - if t is true: - return t - elif t is not false: - r = None - return r + # evaluate=True is needed to override evaluate=False context; + # we need Eq to do the evaluation + return fuzzy_or([tfn[Eq(e, other, evaluate=True)] for e in self.args]) @property def _boundary(self): @@ -1840,9 +1884,11 @@ def imageset(args): if isinstance(set, ImageSet): if len(set.lamda.variables) == 1 and len(f.variables) == 1: - return imageset(Lambda(set.lamda.variables[0], - f.expr.subs(f.variables[0], set.lamda.expr)), - set.base_set) + x = set.lamda.variables[0] + y = f.variables[0] + return imageset( + Lambda(x, f.expr.subs(y, set.lamda.expr)), + set.base_set) if r is not None: return r @@ -1942,7 +1988,7 @@ def simplify_intersection(args): raise TypeError("Input args to Union must be Sets") # If any EmptySets return EmptySet - if any(s.is_EmptySet for s in args): + if S.EmptySet in args: return S.EmptySet # Handle Finite sets diff --git a/sympy/solvers/solveset.py b/sympy/solvers/solveset.py index c3f81669db63..9eb4ba861baf 100644 --- a/sympy/solvers/solveset.py +++ b/sympy/solvers/solveset.py @@ -2364,8 +2364,8 @@ def substitution(system, symbols, result=[{}], known_symbols=[], complements = {} intersections = {} - # when total_solveset_call is equals to total_conditionset - # means solvest fail to solve all the eq. + # when total_solveset_call equals total_conditionset + # it means that solveset failed to solve all eqs. total_conditionset = -1 total_solveset_call = -1	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index ebb6a98cf299..b4911a41de20 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -898,14 +898,21 @@ def test_sympy__sets__setexpr__SetExpr(): assert _test_args(SetExpr(Interval(0, 1))) +def test_sympy__sets__fancysets__Rationals(): + from sympy.sets.fancysets import Rationals + assert _test_args(Rationals()) + + def test_sympy__sets__fancysets__Naturals(): from sympy.sets.fancysets import Naturals assert _test_args(Naturals()) + def test_sympy__sets__fancysets__Naturals0(): from sympy.sets.fancysets import Naturals0 assert _test_args(Naturals0()) + def test_sympy__sets__fancysets__Integers(): from sympy.sets.fancysets import Integers assert _test_args(Integers()) diff --git a/sympy/core/tests/test_function.py b/sympy/core/tests/test_function.py index ff2d4a6ed265..a7bf674bb853 100644 --- a/sympy/core/tests/test_function.py +++ b/sympy/core/tests/test_function.py @@ -207,6 +207,9 @@ def test_Lambda(): raises(TypeError, lambda: Lambda(1, x)) assert Lambda(x, 1)(1) is S.One + raises(SyntaxError, lambda: Lambda((x, x), x + 2)) + + def test_IdentityFunction(): assert Lambda(x, x) is Lambda(y, y) is S.IdentityFunction diff --git a/sympy/sets/tests/test_conditionset.py b/sympy/sets/tests/test_conditionset.py index b976c2c91953..16e34c9de124 100644 --- a/sympy/sets/tests/test_conditionset.py +++ b/sympy/sets/tests/test_conditionset.py @@ -167,4 +167,5 @@ def test_contains(): assert ConditionSet(x, y > 5, Interval(1, 7) ).contains(8) is S.false assert ConditionSet(x, y > 5, Interval(1, 7) - ).contains(w) == And(w >= 1, w <= 7, y > 5) + ).contains(w) == And(S(1) <= w, w <= 7, y > 5) + assert 0 not in ConditionSet(x, 1/x >= 0, S.Reals) diff --git a/sympy/sets/tests/test_contains.py b/sympy/sets/tests/test_contains.py index 4efd8aee97fd..5e8d87d175e7 100644 --- a/sympy/sets/tests/test_contains.py +++ b/sympy/sets/tests/test_contains.py @@ -1,4 +1,5 @@ from sympy import Symbol, Contains, S, Interval, FiniteSet, oo, Eq +from sympy.core.expr import unchanged from sympy.utilities.pytest import raises def test_contains_basic(): @@ -12,8 +13,8 @@ def test_contains_basic(): def test_issue_6194(): x = Symbol('x') - assert Contains(x, Interval(0, 1)) != (x >= 0) & (x <= 1) - assert Interval(0, 1).contains(x) == (x >= 0) & (x <= 1) + assert unchanged(Contains, x, Interval(0, 1)) + assert Interval(0, 1).contains(x) == (S(0) <= x) & (x <= 1) assert Contains(x, FiniteSet(0)) != S.false assert Contains(x, Interval(1, 1)) != S.false assert Contains(x, S.Integers) != S.false diff --git a/sympy/sets/tests/test_fancysets.py b/sympy/sets/tests/test_fancysets.py index 2764c1b7c8fc..87748fb5e8c3 100644 --- a/sympy/sets/tests/test_fancysets.py +++ b/sympy/sets/tests/test_fancysets.py @@ -1,5 +1,4 @@ from sympy.core.compatibility import range, PY3 -from sympy.core.mod import Mod from sympy.sets.fancysets import (ImageSet, Range, normalize_theta_set, ComplexRegion) from sympy.sets.sets import (FiniteSet, Interval, imageset, Union, @@ -32,6 +31,10 @@ def test_naturals(): assert N.inf == 1 assert N.sup == oo + assert not N.contains(oo) + for s in (S.Naturals0, S.Naturals): + assert s.intersection(S.Reals) is s + assert s.is_subset(S.Reals) def test_naturals0(): @@ -39,6 +42,7 @@ def test_naturals0(): assert 0 in N assert -1 not in N assert next(iter(N)) == 0 + assert not N.contains(oo) def test_integers(): @@ -46,6 +50,9 @@ def test_integers(): assert 5 in Z assert -5 in Z assert 5.5 not in Z + assert not Z.contains(oo) + assert not Z.contains(-oo) + zi = iter(Z) a, b, c, d = next(zi), next(zi), next(zi), next(zi) assert (a, b, c, d) == (0, 1, -1, 2) @@ -64,7 +71,8 @@ def test_integers(): def test_ImageSet(): assert ImageSet(Lambda(x, 1), S.Integers) == FiniteSet(1) - assert ImageSet(Lambda(x, y), S.Integers) == FiniteSet(y) + assert ImageSet(Lambda(x, y), S.Integers + ) == {y} squares = ImageSet(Lambda(x, x*2), S.Naturals) assert 4 in squares assert 5 not in squares @@ -385,6 +393,7 @@ def test_Reals(): assert sqrt(-1) not in S.Reals assert S.Reals == Interval(-oo, oo) assert S.Reals != Interval(0, oo) + assert S.Reals.is_subset(Interval(-oo, oo)) def test_Complex(): @@ -802,3 +811,31 @@ def test_issue_16871b(): def test_no_mod_on_imaginary(): assert imageset(Lambda(x, 2x + 3I), S.Integers ) == ImageSet(Lambda(x, 2x + I), S.Integers) + + +def test_Rationals(): + assert S.Integers.is_subset(S.Rationals) + assert S.Naturals.is_subset(S.Rationals) + assert S.Naturals0.is_subset(S.Rationals) + assert S.Rationals.is_subset(S.Reals) + assert S.Rationals.inf == -oo + assert S.Rationals.sup == oo + it = iter(S.Rationals) + assert [next(it) for i in range(12)] == [ + 0, 1, -1, S(1)/2, 2, -S(1)/2, -2, + S(1)/3, 3, -S(1)/3, -3, S(2)/3] + assert Basic() not in S.Rationals + assert S.Half in S.Rationals + assert 1.0 not in S.Rationals + assert 2 in S.Rationals + r = symbols('r', rational=True) + assert r in S.Rationals + raises(TypeError, lambda: x in S.Rationals) + + +def test_imageset_intersection(): + n = Dummy() + s = ImageSet(Lambda(n, -I(I(2pin - pi/4) + + log(Abs(sqrt(-I))))), S.Integers) + assert s.intersect(S.Reals) == ImageSet( + Lambda(n, 2pin + 7pi/4), S.Integers) diff --git a/sympy/sets/tests/test_sets.py b/sympy/sets/tests/test_sets.py index c839ceb4ed4d..67761ce0045c 100644 --- a/sympy/sets/tests/test_sets.py +++ b/sympy/sets/tests/test_sets.py @@ -3,7 +3,7 @@ FiniteSet, Intersection, imageset, I, true, false, ProductSet, E, sqrt, Complement, EmptySet, sin, cos, Lambda, ImageSet, pi, Eq, Pow, Contains, Sum, rootof, SymmetricDifference, Piecewise, - Matrix, signsimp, Range, Add, symbols) + Matrix, signsimp, Range, Add, symbols, zoo) from mpmath import mpi from sympy.core.compatibility import range @@ -14,9 +14,22 @@ def test_imageset(): ints = S.Integers + assert imageset(x, x - 1, S.Naturals) is S.Naturals0 + assert imageset(x, x + 1, S.Naturals0) is S.Naturals + assert imageset(x, abs(x), S.Naturals0) is S.Naturals0 + assert imageset(x, abs(x), S.Naturals) is S.Naturals + assert imageset(x, abs(x), S.Integers) is S.Naturals0 + # issue 16878a + r = symbols('r', real=True) + assert (1, r) not in imageset(x, (x, x), S.Reals) + assert (r, r) in imageset(x, (x, x), S.Reals) + assert 1 + I in imageset(x, x + I, S.Reals) + assert {1} not in imageset(x, (x,), S.Reals) + assert (1, 1) not in imageset(x, (x,) , S.Reals) raises(TypeError, lambda: imageset(x, ints)) raises(ValueError, lambda: imageset(x, y, z, ints)) raises(ValueError, lambda: imageset(Lambda(x, cos(x)), y)) + raises(ValueError, lambda: imageset(Lambda(x, x), ints, ints)) assert imageset(cos, ints) == ImageSet(Lambda(x, cos(x)), ints) def f(x): return cos(x) @@ -24,7 +37,8 @@ def f(x): f = lambda x: cos(x) assert imageset(f, ints) == ImageSet(Lambda(x, cos(x)), ints) assert imageset(x, 1, ints) == FiniteSet(1) - assert imageset(x, y, ints) == FiniteSet(y) + assert imageset(x, y, ints) == {y} + assert imageset((x, y), (1, z), intsS.Reals) == {(1, z)} clash = Symbol('x', integer=true) assert (str(imageset(lambda x: x + clash, Interval(-2, 1)).lamda.expr) in ('_x + x', 'x + _x')) @@ -250,8 +264,8 @@ def test_intersect1(): assert all(i.intersection(S.Integers) is i for i in (S.Naturals, S.Naturals0)) s = S.Naturals0 - assert S.Naturals.intersection(s) is s - assert s.intersection(S.Naturals) is s + assert S.Naturals.intersection(s) is S.Naturals + assert s.intersection(S.Naturals) is S.Naturals x = Symbol('x') assert Interval(0, 2).intersect(Interval(1, 2)) == Interval(1, 2) assert Interval(0, 2).intersect(Interval(1, 2, True)) == \ @@ -508,9 +522,9 @@ def test_contains(): # non-bool results assert Union(Interval(1, 2), Interval(3, 4)).contains(x) == \ - Or(And(x <= 2, x >= 1), And(x <= 4, x >= 3)) + Or(And(S(1) <= x, x <= 2), And(S(3) <= x, x <= 4)) assert Intersection(Interval(1, x), Interval(2, 3)).contains(y) == \ - And(y <= 3, y <= x, y >= 1, y >= 2) + And(y <= 3, y <= x, S(1) <= y, S(2) <= y) assert (S.Complexes).contains(S.ComplexInfinity) == S.false @@ -518,10 +532,10 @@ def test_contains(): def test_interval_symbolic(): x = Symbol('x') e = Interval(0, 1) - assert e.contains(x) == And(0 <= x, x <= 1) + assert e.contains(x) == And(S(0) <= x, x <= 1) raises(TypeError, lambda: x in e) e = Interval(0, 1, True, True) - assert e.contains(x) == And(0 < x, x < 1) + assert e.contains(x) == And(S(0) < x, x < 1) def test_union_contains(): @@ -529,9 +543,10 @@ def test_union_contains(): i1 = Interval(0, 1) i2 = Interval(2, 3) i3 = Union(i1, i2) + assert i3.as_relational(x) == Or(And(S(0) <= x, x <= 1), And(S(2) <= x, x <= 3)) raises(TypeError, lambda: x in i3) e = i3.contains(x) - assert e == Or(And(0 <= x, x <= 1), And(2 <= x, x <= 3)) + assert e == i3.as_relational(x) assert e.subs(x, -0.5) is false assert e.subs(x, 0.5) is true assert e.subs(x, 1.5) is false @@ -1000,7 +1015,7 @@ def test_issue_10113(): def test_issue_10248(): assert list(Intersection(S.Reals, FiniteSet(x))) == [ - And(x < oo, x > -oo)] + (-oo < x) & (x < oo)] def test_issue_9447(): @@ -1114,3 +1129,16 @@ def test_union_intersection_constructor(): assert Union({1}, {2}) == FiniteSet(1, 2) assert Intersection({1, 2}, {2, 3}) == FiniteSet(2) + + +def test_Union_contains(): + assert zoo not in Union( + Interval.open(-oo, 0), Interval.open(0, oo)) + + +@XFAIL +def test_issue_16878b(): + # in intersection_sets for (ImageSet, Set) there is no code + # that handles the base_set of S.Reals like there is + # for Integers + assert imageset(x, (x, x), S.Reals).is_subset(S.Reals*2) is True diff --git a/sympy/vector/tests/test_coordsysrect.py b/sympy/vector/tests/test_coordsysrect.py index 5f749c10e002..3f601a0f4c00 100644 --- a/sympy/vector/tests/test_coordsysrect.py +++ b/sympy/vector/tests/test_coordsysrect.py @@ -436,7 +436,7 @@ def test_check_orthogonality(): a = CoordSys3D('a', transformation=((u, v, z), (cosh(u) cos(v), sinh(u) * sin(v), z))) assert a._check_orthogonality(a._transformation) is True - raises(ValueError, lambda: CoordSys3D('a', transformation=((x, x, z), (x, y, z)))) + raises(ValueError, lambda: CoordSys3D('a', transformation=((x, y, z), (x, x, z)))) raises(ValueError, lambda: CoordSys3D('a', transformation=( (x, y, z), (xsin(y/2)cos(z), xsin(y)sin(z), x*cos(y)))))		[ { "components": [ { "doc": "", "lines": [ 585, 586 ], "name": "StrPrinter._print_Rationals", "signature": "def _print_Rationals(self, expr):", "type": "function" } ], "file": "sympy/printing/str.py" }, { "components"...	[ "test_sympy__sets__fancysets__Rationals", "test_Lambda", "test_issue_6194", "test_naturals", "test_Rationals", "test_imageset", "test_intersect1", "test_contains", "test_interval_symbolic", "test_union_contains", "test_issue_10248" ]	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Rationals added to fancysets <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> closes #9609 with added tests closes #10757 by adding Rationals closes #11863 closes #16268 by defining interaction for Naturals and Reals closes #16938 closes #16940 #### Brief description of what is fixed or changed #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - sets - Rationals added to fancysets - interactions between Z, N, N0 and R is improved <!-- END RELEASE NOTES --> ---------- Rationals here doesn't print nicely: ``` In [1]: S.Rationals Out[1]: Rationals In [2]: S.Reals Out[2]: ℝ In [3]: S.Integers Out[3]: ℤ ``` What is `Rationals.__iter__` useful for? It currently only gives rational numbers between +-1. There is a way to enumerate all rationals in the diagram here though: https://en.wikipedia.org/wiki/Rational_number#Properties This result is driving me crazy...I will have to step through and see why `S.Naturals.intersect(S.Reals) -> Range(1, oo, 1)` but `S.Naturals0` gives itself. ```console def e2d(s): if type(s) is str: s = s.replace('==', '=') return [tuple(map(lambda i:i.strip(), li.split('='))) for li in s.strip().splitlines()] elif isinstance(s, Eq): return s.args elif type(s) is list: return list(map(e2d, s)) e2d('v_f=x\nsigma_f=f\nsigma_c=c\nsigma_p=p') s2d = lambda s: [tuple(map(lambda i:i.strip(), li.split('='))) for li in s.strip().splitlines()] ``` </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/printing/str.py] (definition of StrPrinter._print_Rationals:) def _print_Rationals(self, expr): [end of new definitions in sympy/printing/str.py] [start of new definitions in sympy/sets/conditionset.py] (definition of ConditionSet._contains:) def _contains(self, other): (definition of ConditionSet.as_relational:) def as_relational(self, other): [end of new definitions in sympy/sets/conditionset.py] [start of new definitions in sympy/sets/fancysets.py] (definition of Rationals:) class Rationals(with_metaclass(Singleton, Set)): """Represents the rational numbers. This set is also available as the Singleton, S.Rationals. Examples ======== >>> from sympy import S >>> S.Half in S.Rationals True >>> iterable = iter(S.Rationals) >>> [next(iterable) for i in range(12)] [0, 1, -1, 1/2, 2, -1/2, -2, 1/3, 3, -1/3, -3, 2/3]""" (definition of Rationals._contains:) def _contains(self, other): (definition of Rationals.__iter__:) def __iter__(self): (definition of Rationals._boundary:) def _boundary(self): (definition of Naturals.as_relational:) def as_relational(self, x): (definition of Integers.as_relational:) def as_relational(self, x): [end of new definitions in sympy/sets/fancysets.py] [start of new definitions in sympy/sets/handlers/intersection.py] (definition of _intlike_interval:) def _intlike_interval(a, b): [end of new definitions in sympy/sets/handlers/intersection.py] [start of new definitions in sympy/sets/sets.py] (definition of ProductSet.as_relational:) def as_relational(self, *symbols): [end of new definitions in sympy/sets/sets.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Range._intersect fails when (in a line) the solution is returned in other order Hi all!, well trying to fix some issue i found this, basically, the problem start in this line: fancysets.py:684 ``` a, b = diop_linear(eq(r1, Dummy()) - eq(r2, Dummy())) ``` The return is correct, but the problem is the algorithm applied next with a and b, it only check a, so the problem start when the first the Dummy is sorted after the second Dummy (are sorted by name), so when this happen the return is reversed, not a very big change, b is a, and a is b, is logic because is the same but in other order, well the problem is when is treaty in this case, and basically all intersections when this happen return ```EmptySet()```. To fix this please avoid assign names to Dummy, i think the idea is fix the algorithm to can work with both solutions, a and b to avoid problems in the future. Thx. Cya. ---------- -------------------- </issues>	c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-16845	16,845	sympy/sympy	1.5	6ffc2f04ad820e3f592b2107e66a16fd4585ac02	2019-05-16T22:52:03Z	diff --git a/sympy/tensor/array/__init__.py b/sympy/tensor/array/__init__.py index fac9822cd8c7..ecad09e7545d 100644 --- a/sympy/tensor/array/__init__.py +++ b/sympy/tensor/array/__init__.py @@ -204,5 +204,6 @@ from .sparse_ndim_array import MutableSparseNDimArray, ImmutableSparseNDimArray, SparseNDimArray from .ndim_array import NDimArray from .arrayop import tensorproduct, tensorcontraction, derive_by_array, permutedims +from .array_comprehension import ArrayComprehension Array = ImmutableDenseNDimArray diff --git a/sympy/tensor/array/array_comprehension.py b/sympy/tensor/array/array_comprehension.py new file mode 100644 index 000000000000..ecd452fefbef --- /dev/null +++ b/sympy/tensor/array/array_comprehension.py @@ -0,0 +1,266 @@ +from __future__ import print_function, division +import functools +from sympy.core.sympify import sympify +from sympy.core.expr import Expr +from sympy.core import Basic +from sympy.core.compatibility import Iterable +from sympy.tensor.array import MutableDenseNDimArray, ImmutableDenseNDimArray +from sympy import Symbol +from sympy.core.sympify import sympify +from sympy.core.numbers import Integer + + +class ArrayComprehension(Basic): + """ + Generate a list comprehension + If there is a symbolic dimension, for example, say [i for i in range(1, N)] where + N is a Symbol, then the expression will not be expanded to an array. Otherwise, + calling the doit() function will launch the expansion. + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) + >>> a + ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) + >>> a.doit() + [[11, 12, 13], [21, 22, 23], [31, 32, 33], [41, 42, 43]] + >>> b = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, k)) + >>> b.doit() + ArrayComprehension(10i + j, (i, 1, 4), (j, 1, k)) + + """ + def __new__(cls, function, symbols, assumptions): + if any(len(l) != 3 or None for l in symbols): + raise ValueError('ArrayComprehension requires values lower and upper bound' + ' for the expression') + arglist = [sympify(function)] + arglist.extend(cls._check_limits_validity(function, symbols)) + obj = Basic.__new__(cls, arglist, *assumptions) + obj._function = obj._args[0] + obj._limits = obj._args[1:] + obj._shape = cls._calculate_shape_from_limits(obj._limits) + obj._rank = len(obj._shape) + obj._loop_size = cls._calculate_loop_size(obj._shape) + return obj + + @property + def function(self): + """ + Return the function applied across limits + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) + >>> a.function + 10i + j + """ + return self._function + + @property + def limits(self): + """ + Return a list of the limits that will be applied while expanding the array. Each + bound contrains firstly the an variable (not necessarily to be component of the + expression, e.g. an array of constant). Then the lower bound and the upper bound + define the length of this expansion. + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) + >>> a.limits + ((i, 1, 4), (j, 1, 3)) + """ + return self._limits + + @property + def free_symbols(self): + """ + Return a set of the free_symbols in the array. Variables appeared in the bounds + are supposed to be excluded from the free symbol set. + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) + >>> a.free_symbols + set() + >>> b = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, k+3)) + >>> b.free_symbols + {k} + """ + expr_free_sym = self._function.free_symbols + for var, inf, sup in self._limits: + expr_free_sym.discard(var) + if len(inf.free_symbols) > 0: + expr_free_sym = expr_free_sym.union(inf.free_symbols) + if len(sup.free_symbols) > 0: + expr_free_sym = expr_free_sym.union(sup.free_symbols) + return expr_free_sym + + @property + def variables(self): + """ + Return a list of the variables in the limits + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) + >>> a.variables + [i, j] + """ + return [l[0] for l in self._limits] + + @property + def bound_symbols(self): + """ + Return only variables that are dummy variables. Note that all variables are + dummy variables since a limit without lower bound or upper bound is not accpted. + """ + return [l[0] for l in self._limits if len(l) != 1] + + @property + def shape(self): + """ + Return the shape of the expanded array, which can have symbols. Note that both + the lower and the upper bounds are included while calculating the shape. + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) + >>> a.shape + (4, 3) + >>> b = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, k+3)) + >>> b.shape + (4, k + 3) + """ + return self._shape + + @property + def is_numeric(self): + """ + Return True if the expanded array is numeric, which means that there is not + symbolic dimension. + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) + >>> a.is_numeric + True + >>> b = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, k+3)) + >>> b.is_numeric + False + + """ + for var, inf, sup in self._limits: + if Basic(inf, sup).atoms(Symbol): + return False + return True + + def rank(self): + """ + Return the rank of the expanded array. + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) + >>> a.rank() + 2 + """ + return self._rank + + def __len__(self): + """ + Overload common function len().Returns the number of element in the expanded + array. Note that symbolic length is not supported and will raise an error. + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) + >>> len(a) + 12 + """ + if len(self._loop_size.free_symbols) != 0: + raise ValueError('Symbolic length is not supported') + return self._loop_size + + @classmethod + def _check_limits_validity(cls, function, limits): + limits = sympify(limits) + for var, inf, sup in limits: + if any(not isinstance(i, Expr) for i in [inf, sup]): + raise TypeError('Bounds should be an Expression(combination of Integer and Symbol)') + if (inf > sup) == True: + raise ValueError('Lower bound should be inferior to upper bound') + if var in inf.free_symbols or var in sup.free_symbols: + raise ValueError('Variable should not be part of its bounds') + return limits + + @classmethod + def _calculate_shape_from_limits(cls, limits): + shape = [] + for var, inf, sup in limits: + shape.append(sup - inf + 1) + return tuple(shape) + + @classmethod + def _calculate_loop_size(cls, shape): + if len(shape) == 0: + return 0 + loop_size = 1 + for l in shape: + loop_size = loop_size l + + return loop_size + + def doit(self): + if not self.is_numeric: + return self + + arr = self._expand_array() + return arr + + def _expand_array(self): + # To perform a subs at every element of the array. + def _array_subs(arr, var, val): + arr = MutableDenseNDimArray(arr) + for i in range(len(arr)): + index = arr._get_tuple_index(i) + arr[index] = arr[index].subs(var, val) + return arr.tolist() + + list_gen = self._function + for var, inf, sup in reversed(self._limits): + list_expr = list_gen + list_gen = [] + for val in range(inf, sup+1): + if not isinstance(list_expr, Iterable): + list_gen.append(list_expr.subs(var, val)) + else: + list_gen.append(_array_subs(list_expr, var, val)) + return ImmutableDenseNDimArray(list_gen)	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 098a0a559ca2..f7ae7575bfd5 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -3843,6 +3843,12 @@ def test_sympy__tensor__array__sparse_ndim_array__ImmutableSparseNDimArray(): assert _test_args(sparr) +def test_sympy__tensor__array__array_comprehension__ArrayComprehension(): + from sympy.tensor.array.array_comprehension import ArrayComprehension + arrcom = ArrayComprehension(x, (x, 1, 5)) + assert _test_args(arrcom) + + def test_sympy__tensor__functions__TensorProduct(): from sympy.tensor.functions import TensorProduct tp = TensorProduct(3, 4, evaluate=False) diff --git a/sympy/tensor/array/tests/test_array_comprehension.py b/sympy/tensor/array/tests/test_array_comprehension.py new file mode 100644 index 000000000000..dfd35877417c --- /dev/null +++ b/sympy/tensor/array/tests/test_array_comprehension.py @@ -0,0 +1,41 @@ +from sympy.tensor.array.array_comprehension import ArrayComprehension +from sympy.tensor.array import ImmutableDenseNDimArray +from sympy.abc import i, j, k, l, n +from sympy.utilities.pytest import raises + + +def test_array_comprehension(): + a = ArrayComprehension(ij, (i, 1, 3), (j, 2, 4)) + b = ArrayComprehension(i, (i, 1, j+1)) + c = ArrayComprehension(i+j+k+l, (i, 1, 2), (j, 1, 3), (k, 1, 4), (l, 1, 5)) + d = ArrayComprehension(k, (i, 1, 5)) + e = ArrayComprehension(i, (j, k+1, k+5)) + assert a.doit().tolist() == [[2, 3, 4], [4, 6, 8], [6, 9, 12]] + assert a.shape == (3, 3) + assert a.is_numeric == True + assert len(a) == 9 + assert isinstance(b.doit(), ArrayComprehension) + assert isinstance(a.doit(), ImmutableDenseNDimArray) + assert b.subs(j, 3) == ArrayComprehension(i, (i, 1, 4)) + assert b.free_symbols == {j} + assert b.shape == (j + 1,) + assert b.rank() == 1 + assert b.is_numeric == False + assert c.free_symbols == set() + assert c.function == i + j + k + l + assert c.limits == ((i, 1, 2), (j, 1, 3), (k, 1, 4), (l, 1, 5)) + assert c.doit().tolist() == [[[[4, 5, 6, 7, 8], [5, 6, 7, 8, 9], [6, 7, 8, 9, 10], [7, 8, 9, 10, 11]], + [[5, 6, 7, 8, 9], [6, 7, 8, 9, 10], [7, 8, 9, 10, 11], [8, 9, 10, 11, 12]], + [[6, 7, 8, 9, 10], [7, 8, 9, 10, 11], [8, 9, 10, 11, 12], [9, 10, 11, 12, 13]]], + [[[5, 6, 7, 8, 9], [6, 7, 8, 9, 10], [7, 8, 9, 10, 11], [8, 9, 10, 11, 12]], + [[6, 7, 8, 9, 10], [7, 8, 9, 10, 11], [8, 9, 10, 11, 12], [9, 10, 11, 12, 13]], + [[7, 8, 9, 10, 11], [8, 9, 10, 11, 12], [9, 10, 11, 12, 13], [10, 11, 12, 13, 14]]]] + assert c.free_symbols == set() + assert c.variables == [i, j, k, l] + assert c.bound_symbols == [i, j, k, l] + assert d.doit().tolist() == [k, k, k, k, k] + assert len(e) == 5 + raises(TypeError, lambda: ArrayComprehension(ij, (i, 1, 3), (j, 2, [1, 3, 2]))) + raises(ValueError, lambda: ArrayComprehension(ij, (i, 1, 3), (j, 2, 1))) + raises(ValueError, lambda: ArrayComprehension(ij, (i, 1, 3), (j, 2, j+1))) + raises(ValueError, lambda: len(ArrayComprehension(i*j, (i, 1, 3), (j, 2, j+4))))		[ { "components": [ { "doc": "Generate a list comprehension\nIf there is a symbolic dimension, for example, say [i for i in range(1, N)] where\nN is a Symbol, then the expression will not be expanded to an array. Otherwise,\ncalling the doit() function will launch the expansion.\n\nExamples\n=======...	[ "test_sympy__tensor__array__array_comprehension__ArrayComprehension" ]	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [Don't merge][GSoC]Added ArrayComprehension class <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed Added ArrayComprehension class to generate a list comprehension which can accept symbols #### Other comments The implementation is not yet finished. PR related to GSoC 2019 #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * tensor * Added a new array object ArrayComprehension for list comprehension. <!-- END RELEASE NOTES --> TODO list: - [x] add unit tests - [x] add doctests in the documentation string. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/tensor/array/array_comprehension.py] (definition of ArrayComprehension:) class ArrayComprehension(Basic): """Generate a list comprehension If there is a symbolic dimension, for example, say [i for i in range(1, N)] where N is a Symbol, then the expression will not be expanded to an array. Otherwise, calling the doit() function will launch the expansion. Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) >>> a ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) >>> a.doit() [[11, 12, 13], [21, 22, 23], [31, 32, 33], [41, 42, 43]] >>> b = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, k)) >>> b.doit() ArrayComprehension(10i + j, (i, 1, 4), (j, 1, k))""" (definition of ArrayComprehension.__new__:) def __new__(cls, function, symbols, assumptions): (definition of ArrayComprehension.function:) def function(self): """Return the function applied across limits Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) >>> a.function 10i + j""" (definition of ArrayComprehension.limits:) def limits(self): """Return a list of the limits that will be applied while expanding the array. Each bound contrains firstly the an variable (not necessarily to be component of the expression, e.g. an array of constant). Then the lower bound and the upper bound define the length of this expansion. Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) >>> a.limits ((i, 1, 4), (j, 1, 3))""" (definition of ArrayComprehension.free_symbols:) def free_symbols(self): """Return a set of the free_symbols in the array. Variables appeared in the bounds are supposed to be excluded from the free symbol set. Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) >>> a.free_symbols set() >>> b = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, k+3)) >>> b.free_symbols {k}""" (definition of ArrayComprehension.variables:) def variables(self): """Return a list of the variables in the limits Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) >>> a.variables [i, j]""" (definition of ArrayComprehension.bound_symbols:) def bound_symbols(self): """Return only variables that are dummy variables. Note that all variables are dummy variables since a limit without lower bound or upper bound is not accpted.""" (definition of ArrayComprehension.shape:) def shape(self): """Return the shape of the expanded array, which can have symbols. Note that both the lower and the upper bounds are included while calculating the shape. Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) >>> a.shape (4, 3) >>> b = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, k+3)) >>> b.shape (4, k + 3)""" (definition of ArrayComprehension.is_numeric:) def is_numeric(self): """Return True if the expanded array is numeric, which means that there is not symbolic dimension. Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) >>> a.is_numeric True >>> b = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, k+3)) >>> b.is_numeric False""" (definition of ArrayComprehension.rank:) def rank(self): """Return the rank of the expanded array. Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10i + j, (i, 1, 4), (j, 1, 3)) >>> a.rank() 2""" (definition of ArrayComprehension.__len__:) def __len__(self): """Overload common function len().Returns the number of element in the expanded array. Note that symbolic length is not supported and will raise an error. Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) >>> len(a) 12""" (definition of ArrayComprehension._check_limits_validity:) def _check_limits_validity(cls, function, limits): (definition of ArrayComprehension._calculate_shape_from_limits:) def _calculate_shape_from_limits(cls, limits): (definition of ArrayComprehension._calculate_loop_size:) def _calculate_loop_size(cls, shape): (definition of ArrayComprehension.doit:) def doit(self): (definition of ArrayComprehension._expand_array:) def _expand_array(self): (definition of ArrayComprehension._expand_array._array_subs:) def _array_subs(arr, var, val): [end of new definitions in sympy/tensor/array/array_comprehension.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-16843	16,843	sympy/sympy	1.5	d2308e8eb55ed6acb24bcd8dbb8c410c9e5e9d5c	2019-05-16T13:22:59Z	diff --git a/sympy/functions/__init__.py b/sympy/functions/__init__.py index bcacdc3c08f6..83049f5e0b37 100644 --- a/sympy/functions/__init__.py +++ b/sympy/functions/__init__.py @@ -26,7 +26,7 @@ erfinv, erfcinv, erf2inv, Ei, expint, E1, li, Li, Si, Ci, Shi, Chi, fresnels, fresnelc) from sympy.functions.special.gamma_functions import (gamma, lowergamma, - uppergamma, polygamma, loggamma, digamma, trigamma) + uppergamma, polygamma, loggamma, digamma, trigamma, multigamma) from sympy.functions.special.zeta_functions import (dirichlet_eta, zeta, lerchphi, polylog, stieltjes) from sympy.functions.special.tensor_functions import (Eijk, LeviCivita, diff --git a/sympy/functions/special/gamma_functions.py b/sympy/functions/special/gamma_functions.py index c4cdd69841ab..ee79a3597770 100644 --- a/sympy/functions/special/gamma_functions.py +++ b/sympy/functions/special/gamma_functions.py @@ -1,12 +1,13 @@ from __future__ import print_function, division -from sympy.core import Add, S, sympify, oo, pi, Dummy, expand_func +from sympy.core import Add, S, sympify, oo, pi, Symbol, Dummy, expand_func from sympy.core.compatibility import range, as_int from sympy.core.function import Function, ArgumentIndexError from sympy.core.numbers import Rational from sympy.core.power import Pow -from .zeta_functions import zeta -from .error_functions import erf, erfc +from sympy.core.logic import fuzzy_and, fuzzy_not +from sympy.functions.special.zeta_functions import zeta +from sympy.functions.special.error_functions import erf, erfc from sympy.functions.elementary.exponential import exp, log from sympy.functions.elementary.integers import ceiling, floor from sympy.functions.elementary.miscellaneous import sqrt @@ -165,6 +166,10 @@ def _eval_conjugate(self): def _eval_is_real(self): x = self.args[0] + if x.is_nonpositive and x.is_integer: + return False + if intlike(x) and x <= 0: + return False if x.is_positive or x.is_noninteger: return True @@ -640,7 +645,7 @@ def _eval_aseries(self, n, args0, x, logx): @classmethod def eval(cls, n, z): - n, z = list(map(sympify, (n, z))) + n, z = map(sympify, (n, z)) from sympy import unpolarify if n.is_integer: @@ -1015,3 +1020,97 @@ def trigamma(x): .. [3] http://functions.wolfram.com/GammaBetaErf/PolyGamma2/ """ return polygamma(1, x) + +############################################################################### +##################### COMPLETE MULTIVARIATE GAMMA FUNCTION #################### +############################################################################### + + +class multigamma(Function): + r""" + The multivariate gamma function is a generalization of the gamma function i.e, + + .. math:: + \Gamma_p(z) = \pi^{p(p-1)/4}\prod_{k=1}^p \Gamma[z + (1 - k)/2]. + + Special case, multigamma(x, 1) = gamma(x) + + Parameters + ========== + + p: order or dimension of the multivariate gamma function + + Examples + ======== + + >>> from sympy import S, I, pi, oo, gamma, multigamma + >>> from sympy import Symbol + >>> x = Symbol('x') + >>> p = Symbol('p', positive=True, integer=True) + + >>> multigamma(x, p) + pi*(p(p - 1)/4)Product(gamma(-_k/2 + x + 1/2), (_k, 1, p)) + + Several special values are known: + >>> multigamma(1, 1) + 1 + >>> multigamma(4, 1) + 6 + >>> multigamma(S(3)/2, 1) + sqrt(pi)/2 + + Writing multigamma in terms of gamma function + >>> multigamma(x, 1) + gamma(x) + + >>> multigamma(x, 2) + sqrt(pi)gamma(x)gamma(x - 1/2) + + >>> multigamma(x, 3) + pi(3/2)gamma(x)gamma(x - 1)gamma(x - 1/2) + + See Also + ======== + + gamma, lowergamma, uppergamma, polygamma, loggamma, digamma, trigamma + sympy.functions.special.beta_functions.beta + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Multivariate_gamma_function + """ + unbranched = True + + def fdiff(self, argindex=2): + from sympy import Sum + if argindex == 2: + x, p = self.args + k = Dummy("k") + return self.func(x, p)Sum(polygamma(0, x + (1 - k)/2), (k, 1, p)) + else: + raise ArgumentIndexError(self, argindex) + + @classmethod + def eval(cls, x, p): + from sympy import Product + x, p = map(sympify, (x, p)) + if p.is_positive is False or p.is_integer is False: + raise ValueError('Order parameter p must be positive integer.') + k = Dummy("k") + return (pi(p(p - 1)/4)Product(gamma(x + (1 - k)/2), + (k, 1, p))).doit() + + def _eval_conjugate(self): + x, p = self.args + return self.func(x.conjugate(), p) + + def _eval_is_real(self): + x, p = self.args + y = 2x + if y.is_integer and (y <= (p - 1)) is True: + return False + if intlike(y) and (y <= (p - 1)): + return False + if y > (p - 1) or y.is_noninteger: + return True	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 1a03df681874..37756114b63b 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -2218,6 +2218,10 @@ def test_sympy__functions__special__gamma_functions__uppergamma(): from sympy.functions.special.gamma_functions import uppergamma assert _test_args(uppergamma(x, 2)) +def test_sympy__functions__special__gamma_functions__multigamma(): + from sympy.functions.special.gamma_functions import multigamma + assert _test_args(multigamma(x, 1)) + def test_sympy__functions__special__beta_functions__beta(): from sympy.functions.special.beta_functions import beta diff --git a/sympy/functions/special/tests/test_gamma_functions.py b/sympy/functions/special/tests/test_gamma_functions.py index 5adba2623a84..1c94267bee41 100644 --- a/sympy/functions/special/tests/test_gamma_functions.py +++ b/sympy/functions/special/tests/test_gamma_functions.py @@ -1,7 +1,8 @@ from sympy import ( - Symbol, gamma, I, oo, nan, zoo, factorial, sqrt, Rational, log, - polygamma, EulerGamma, pi, uppergamma, S, expand_func, loggamma, sin, - cos, O, lowergamma, exp, erf, erfc, exp_polar, harmonic, zeta,conjugate) + Symbol, Dummy, gamma, I, oo, nan, zoo, factorial, sqrt, Rational, + multigamma, log, polygamma, EulerGamma, pi, uppergamma, S, expand_func, + loggamma, sin, cos, O, lowergamma, exp, erf, erfc, exp_polar, harmonic, + zeta, conjugate) from sympy.core.expr import unchanged from sympy.core.function import ArgumentIndexError @@ -73,6 +74,15 @@ def test_gamma(): assert gamma(3exp_polar(Ipi)/4).is_nonnegative is False assert gamma(3exp_polar(Ipi)/4).is_extended_nonpositive is True + y = Symbol('y', nonpositive=True, integer=True) + assert gamma(y).is_real == False + y = Symbol('y', positive=True, noninteger=True) + assert gamma(y).is_real == True + + assert gamma(-1.0, evaluate=False).is_real == False + assert gamma(0, evaluate=False).is_real == False + assert gamma(-2, evaluate=False).is_real == False + def test_gamma_rewrite(): assert gamma(n).rewrite(factorial) == factorial(n - 1) @@ -413,7 +423,7 @@ def test_issue_8657(): m = Symbol('m', integer=True) o = Symbol('o', positive=True) p = Symbol('p', negative=True, integer=False) - assert gamma(n).is_real is None + assert gamma(n).is_real is False assert gamma(m).is_real is None assert gamma(o).is_real is True assert gamma(p).is_real is True @@ -447,3 +457,62 @@ def test_issue_14450(): def test_issue_14528(): k = Symbol('k', integer=True, nonpositive=True) assert isinstance(gamma(k), gamma) + +def test_multigamma(): + from sympy import Product + p = Symbol('p') + _k = Dummy('_k') + + assert multigamma(x, p).dummy_eq(pi*(p(p - 1)/4)\ + Product(gamma(x + (1 - _k)/2), (_k, 1, p))) + + assert conjugate(multigamma(x, p)).dummy_eq(pi((conjugate(p) - 1)\ + conjugate(p)/4)Product(gamma(conjugate(x) + (1-conjugate(_k))/2), (_k, 1, p))) + assert conjugate(multigamma(x, 1)) == gamma(conjugate(x)) + + p = Symbol('p', positive=True) + assert conjugate(multigamma(x, p)).dummy_eq(pi((p - 1)p/4)\ + Product(gamma(conjugate(x) + (1-conjugate(_k))/2), (_k, 1, p))) + + assert multigamma(nan, 1) == nan + assert multigamma(oo, 1).doit() == oo + + assert multigamma(1, 1) == 1 + assert multigamma(2, 1) == 1 + assert multigamma(3, 1) == 2 + + assert multigamma(102, 1) == factorial(101) + assert multigamma(Rational(1, 2), 1) == sqrt(pi) + + assert multigamma(1, 2) == pi + assert multigamma(2, 2) == pi/2 + + assert multigamma(1, 3) == zoo + assert multigamma(2, 3) == pi2/2 + assert multigamma(3, 3) == 3pi*2/2 + + assert multigamma(x, 1).diff(x) == gamma(x)polygamma(0, x) + assert multigamma(x, 2).diff(x) == sqrt(pi)gamma(x)gamma(x - S(1)/2)\ + polygamma(0, x) + sqrt(pi)gamma(x)gamma(x - S(1)/2)polygamma(0, x - S(1)/2) + + assert multigamma(x - 1, 1).expand(func=True) == gamma(x)/(x - 1) + assert multigamma(x + 2, 1).expand(func=True, mul=False) == x(x + 1)\ + gamma(x) + assert multigamma(x - 1, 2).expand(func=True) == sqrt(pi)gamma(x)\ + gamma(x + S(1)/2)/(x*3 - 3x*2 + 11x/4 - S(3)/4) + assert multigamma(x - 1, 3).expand(func=True) == pi*(S(3)/2)gamma(x)*2\ + gamma(x + S(1)/2)/(x*5 - 6x*4 + 55x*3/4 - 15x*2 + 31x/4 - S(3)/2) + + assert multigamma(n, 1).rewrite(factorial) == factorial(n - 1) + assert multigamma(n, 2).rewrite(factorial) == sqrt(pi)\ + factorial(n - S(3)/2)factorial(n - 1) + assert multigamma(n, 3).rewrite(factorial) == pi*(S(3)/2)\ + factorial(n - 2)factorial(n - S(3)/2)factorial(n - 1) + + assert multigamma(-S(1)/2, 3, evaluate=False).is_real == False + assert multigamma(S(1)/2, 3, evaluate=False).is_real == False + assert multigamma(0, 1, evaluate=False).is_real == False + assert multigamma(1, 3, evaluate=False).is_real == False + assert multigamma(-1.0, 3, evaluate=False).is_real == False + assert multigamma(0.7, 3, evaluate=False).is_real == True + assert multigamma(3, 3, evaluate=False).is_real == True		[ { "components": [ { "doc": "The multivariate gamma function is a generalization of the gamma function i.e,\n\n.. math::\n \\Gamma_p(z) = \\pi^{p(p-1)/4}\\prod_{k=1}^p \\Gamma[z + (1 - k)/2].\n\nSpecial case, multigamma(x, 1) = gamma(x)\n\nParameters\n==========\n\np: order or dimension of the m...	[ "test_sympy__functions__special__gamma_functions__multigamma", "test_gamma", "test_gamma_rewrite", "test_gamma_series", "test_lowergamma", "test_uppergamma", "test_polygamma", "test_polygamma_expand_func", "test_loggamma", "test_polygamma_expansion", "test_issue_8657", "test_issue_8524", "te...	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added multigamma function <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> This is a new PR which was created because I made a blunder with old PR: https://github.com/sympy/sympy/pull/16822 #### Brief description of what is fixed or changed Multivariate Gamma function is added in `sympy/functions/special/gamma_functions.py` Need to discuss with mentors if this is needed or not. Will add test after finalization. #### Other comments `Multivariate Gamma function` is a generalization of `Gamma function` and is useful in multivariate statistics appearing in the probability density function of the `Wishart` and `inverse Wishart` distributions, and the `matrix variate beta` distribution. #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - functions - Added `multigamma` function in `sympy/functions/special/gamma_functions.py` <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/functions/special/gamma_functions.py] (definition of multigamma:) class multigamma(Function): """The multivariate gamma function is a generalization of the gamma function i.e, .. math:: \Gamma_p(z) = \pi^{p(p-1)/4}\prod_{k=1}^p \Gamma[z + (1 - k)/2]. Special case, multigamma(x, 1) = gamma(x) Parameters ========== p: order or dimension of the multivariate gamma function Examples ======== >>> from sympy import S, I, pi, oo, gamma, multigamma >>> from sympy import Symbol >>> x = Symbol('x') >>> p = Symbol('p', positive=True, integer=True) >>> multigamma(x, p) pi*(p(p - 1)/4)Product(gamma(-_k/2 + x + 1/2), (_k, 1, p)) Several special values are known: >>> multigamma(1, 1) 1 >>> multigamma(4, 1) 6 >>> multigamma(S(3)/2, 1) sqrt(pi)/2 Writing multigamma in terms of gamma function >>> multigamma(x, 1) gamma(x) >>> multigamma(x, 2) sqrt(pi)gamma(x)gamma(x - 1/2) >>> multigamma(x, 3) pi(3/2)gamma(x)gamma(x - 1)gamma(x - 1/2) See Also ======== gamma, lowergamma, uppergamma, polygamma, loggamma, digamma, trigamma sympy.functions.special.beta_functions.beta References ========== .. [1] https://en.wikipedia.org/wiki/Multivariate_gamma_function""" (definition of multigamma.fdiff:) def fdiff(self, argindex=2): (definition of multigamma.eval:) def eval(cls, x, p): (definition of multigamma._eval_conjugate:) def _eval_conjugate(self): (definition of multigamma._eval_is_real:) def _eval_is_real(self): [end of new definitions in sympy/functions/special/gamma_functions.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
pvlib__pvlib-python-718	718	pvlib/pvlib-python	0.5	3c84edd644fa4db54955e2225a183fa3e0405eb0	2019-05-13T14:43:11Z	diff --git a/ci/requirements-py35.yml b/ci/requirements-py35.yml index 65b5c76d00..5fc0077991 100644 --- a/ci/requirements-py35.yml +++ b/ci/requirements-py35.yml @@ -24,4 +24,5 @@ dependencies: - shapely # pvfactors dependency - siphon # conda-forge - pip: + - nrel-pysam - pvfactors==1.0.1 diff --git a/ci/requirements-py36.yml b/ci/requirements-py36.yml index a21bce2579..e415f67c7d 100644 --- a/ci/requirements-py36.yml +++ b/ci/requirements-py36.yml @@ -24,4 +24,5 @@ dependencies: - shapely # pvfactors dependency - siphon # conda-forge - pip: + - nrel-pysam - pvfactors==1.0.1 diff --git a/ci/requirements-py37.yml b/ci/requirements-py37.yml index 3783e8f772..1a6809fba6 100644 --- a/ci/requirements-py37.yml +++ b/ci/requirements-py37.yml @@ -24,4 +24,5 @@ dependencies: - shapely # pvfactors dependency - siphon # conda-forge - pip: + - nrel-pysam - pvfactors==1.0.1 diff --git a/docs/sphinx/source/api.rst b/docs/sphinx/source/api.rst index 8af2bf0f40..6e93dc5807 100644 --- a/docs/sphinx/source/api.rst +++ b/docs/sphinx/source/api.rst @@ -294,6 +294,14 @@ PVWatts model pvsystem.pvwatts_losses pvsystem.pvwatts_losses +Functions for fitting PV models +------------------------------- +.. autosummary:: + :toctree: generated/ + + ivtools.fit_sde_sandia + ivtools.fit_sdm_cec_sam + Other ----- diff --git a/docs/sphinx/source/whatsnew/v0.7.0.rst b/docs/sphinx/source/whatsnew/v0.7.0.rst index d9045a5cfb..9405eac906 100644 --- a/docs/sphinx/source/whatsnew/v0.7.0.rst +++ b/docs/sphinx/source/whatsnew/v0.7.0.rst @@ -104,6 +104,26 @@ Documentation ~~~~~~~~~~~~~ * Corrected docstring for `pvsystem.PVSystem.sapm` +API Changes +~~~~~~~~~~~ + + +Enhancements +~~~~~~~~~~~~ +* Add `ivtools` module to contain functions for IV model fitting. +* Add :py:func:`~pvlib.ivtools.fit_sde_sandia`, a simple method to fit + the single diode equation to an IV curve. +* Add :py:func:`~pvlib.ivtools.fit_sdm_cec_sam`, a wrapper for the CEC single + diode model fitting function '6parsolve' from NREL's System Advisor Model. + + +Bug fixes +~~~~~~~~~ + + +Testing +~~~~~~~ + Removal of prior version deprecations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * Removed `irradiance.extraradiation`. @@ -119,6 +139,7 @@ Contributors ~~~~~~~~~~~~ * Mark Campanellli (:ghuser:`markcampanelli`) * Will Holmgren (:ghuser:`wholmgren`) +* Cliff Hansen (:ghuser:`cwhanse`) * Oscar Dowson (:ghuser:`odow`) * Anton Driesse (:ghuser:`adriesse`) * Alexander Morgan (:ghuser:`alexandermorgan`) diff --git a/pvlib/__init__.py b/pvlib/__init__.py index a1fb92eadd..f4e3de4146 100644 --- a/pvlib/__init__.py +++ b/pvlib/__init__.py @@ -7,6 +7,7 @@ from pvlib import location from pvlib import solarposition from pvlib import iotools +from pvlib import ivtools from pvlib import tracking from pvlib import pvsystem from pvlib import spa diff --git a/pvlib/ivtools.py b/pvlib/ivtools.py new file mode 100644 index 0000000000..353a0b8a9a --- /dev/null +++ b/pvlib/ivtools.py @@ -0,0 +1,350 @@ +# -- coding: utf-8 -- +""" +Created on Fri Mar 29 10:34:10 2019 + +@author: cwhanse +""" + +import numpy as np + + +def fit_sdm_cec_sam(celltype, v_mp, i_mp, v_oc, i_sc, alpha_sc, beta_voc, + gamma_pmp, cells_in_series, temp_ref=25): + """ + Estimates parameters for the CEC single diode model (SDM) using the SAM + SDK. + + Parameters + ---------- + celltype : str + Value is one of 'monoSi', 'multiSi', 'polySi', 'cis', 'cigs', 'cdte', + 'amorphous' + v_mp : float + Voltage at maximum power point [V] + i_mp : float + Current at maximum power point [A] + v_oc : float + Open circuit voltage [V] + i_sc : float + Short circuit current [A] + alpha_sc : float + Temperature coefficient of short circuit current [A/C] + beta_voc : float + Temperature coefficient of open circuit voltage [V/C] + gamma_pmp : float + Temperature coefficient of power at maximum point point [%/C] + cells_in_series : int + Number of cells in series + temp_ref : float, default 25 + Reference temperature condition [C] + + Returns + ------- + tuple of the following elements: + + * I_L_ref : float + The light-generated current (or photocurrent) at reference + conditions [A] + + * I_o_ref : float + The dark or diode reverse saturation current at reference + conditions [A] + + * R_sh_ref : float + The shunt resistance at reference conditions, in ohms. + + * R_s : float + The series resistance at reference conditions, in ohms. + + * a_ref : float + The product of the usual diode ideality factor ``n`` (unitless), + number of cells in series ``Ns``, and cell thermal voltage at + reference conditions [V] + + * Adjust : float + The adjustment to the temperature coefficient for short circuit + current, in percent. + + Raises + ------ + ImportError if NREL-PySAM is not installed. + + RuntimeError if parameter extraction is not successful. + + Notes + ----- + Inputs ``v_mp``, ``v_oc``, ``i_mp`` and ``i_sc`` are assumed to be from a + single IV curve at constant irradiance and cell temperature. Irradiance is + not explicitly used by the fitting procedure. The irradiance level at which + the input IV curve is determined and the specified cell temperature + ``temp_ref`` are the reference conditions for the output parameters + ``I_L_ref``, ``I_o_ref``, ``R_sh_ref``, ``R_s``, ``a_ref`` and ``Adjust``. + + References + ---------- + [1] A. Dobos, "An Improved Coefficient Calculator for the California + Energy Commission 6 Parameter Photovoltaic Module Model", Journal of + Solar Energy Engineering, vol 134, 2012. + """ + + try: + from PySAM import PySSC + except ImportError: + raise ImportError("Requires NREL's PySAM package at " + "https://pypi.org/project/NREL-PySAM/.") + + datadict = {'tech_model': '6parsolve', 'financial_model': 'none', + 'celltype': celltype, 'Vmp': v_mp, + 'Imp': i_mp, 'Voc': v_oc, 'Isc': i_sc, 'alpha_isc': alpha_sc, + 'beta_voc': beta_voc, 'gamma_pmp': gamma_pmp, + 'Nser': cells_in_series, 'Tref': temp_ref} + + result = PySSC.ssc_sim_from_dict(datadict) + if result['cmod_success'] == 1: + return tuple([result[k] for k in ['Il', 'Io', 'Rsh', 'Rs', 'a', + 'Adj']]) + else: + raise RuntimeError('Parameter estimation failed') + + +def fit_sde_sandia(voltage, current, v_oc=None, i_sc=None, v_mp_i_mp=None, + vlim=0.2, ilim=0.1): + r""" + Fits the single diode equation (SDE) to an IV curve. + + Parameters + ---------- + voltage : ndarray + 1D array of `float` type containing voltage at each point on the IV + curve, increasing from 0 to ``v_oc`` inclusive [V] + + current : ndarray + 1D array of `float` type containing current at each point on the IV + curve, from ``i_sc`` to 0 inclusive [A] + + v_oc : float, default None + Open circuit voltage [V]. If not provided, ``v_oc`` is taken as the + last point in the ``voltage`` array. + + i_sc : float, default None + Short circuit current [A]. If not provided, ``i_sc`` is taken as the + first point in the ``current`` array. + + v_mp_i_mp : tuple of float, default None + Voltage, current at maximum power point in units of [V], [A]. + If not provided, the maximum power point is found at the maximum of + ``voltage`` \times ``current``. + + vlim : float, default 0.2 + Defines portion of IV curve where the exponential term in the single + diode equation can be neglected, i.e. + ``voltage`` <= ``vlim`` x ``v_oc`` [V] + + ilim : float, default 0.1 + Defines portion of the IV curve where the exponential term in the + single diode equation is signficant, approximately defined by + ``current`` < (1 - ``ilim``) x ``i_sc`` [A] + + Returns + ------- + tuple of the following elements: + + * photocurrent : float + photocurrent [A] + * saturation_current : float + dark (saturation) current [A] + * resistance_shunt : float + shunt (parallel) resistance, in ohms + * resistance_series : float + series resistance, in ohms + * nNsVth : float + product of thermal voltage ``Vth`` [V], diode ideality factor + ``n``, and number of series cells ``Ns`` + + Raises + ------ + RuntimeError if parameter extraction is not successful. + + Notes + ----- + Inputs ``voltage``, ``current``, ``v_oc``, ``i_sc`` and ``v_mp_i_mp`` are + assumed to be from a single IV curve at constant irradiance and cell + temperature. + + :py:func:`fit_single_diode_sandia` obtains values for the five parameters + for the single diode equation [1]: + + .. math:: + + I = I_{L} - I_{0} (\exp \frac{V + I R_{s}}{nNsVth} - 1) + - \frac{V + I R_{s}}{R_{sh}} + + See :py:func:`pvsystem.singlediode` for definition of the parameters. + + The extraction method [2] proceeds in six steps. + + 1. In the single diode equation, replace :math:`R_{sh} = 1/G_{p}` and + re-arrange + + .. math:: + + I = \frac{I_{L}}{1 + G_{p} R_{s}} - \frac{G_{p} V}{1 + G_{p} R_{s}} + - \frac{I_{0}}{1 + G_{p} R_{s}} (\exp(\frac{V + I R_{s}}{nNsVth}) - 1) + + 2. The linear portion of the IV curve is defined as + :math:`V \le vlim \times v_oc`. Over this portion of the IV curve, + + .. math:: + + \frac{I_{0}}{1 + G_{p} R_{s}} (\exp(\frac{V + I R_{s}}{nNsVth}) - 1) + \approx 0 + + 3. Fit the linear portion of the IV curve with a line. + + .. math:: + + I &\approx \frac{I_{L}}{1 + G_{p} R_{s}} - \frac{G_{p} V}{1 + G_{p} + R_{s}} \\ + &= \beta_{0} + \beta_{1} V + + 4. The exponential portion of the IV curve is defined by + :math:`\beta_{0} + \beta_{1} \times V - I > ilim \times i_sc`. + Over this portion of the curve, :math:`exp((V + IRs)/nNsVth) >> 1` + so that + + .. math:: + + \exp(\frac{V + I R_{s}}{nNsVth}) - 1 \approx + \exp(\frac{V + I R_{s}}{nNsVth}) + + 5. Fit the exponential portion of the IV curve. + + .. math:: + + \log(\beta_{0} - \beta_{1} V - I) + &\approx \log(\frac{I_{0}}{1 + G_{p} R_{s}} + \frac{V}{nNsVth} + + \frac{I R_{s}}{nNsVth} \\ + &= \beta_{2} + beta_{3} V + \beta_{4} I + + 6. Calculate values for ``IL, I0, Rs, Rsh,`` and ``nNsVth`` from the + regression coefficents :math:`\beta_{0}, \beta_{1}, \beta_{3}` and + :math:`\beta_{4}`. + + + References + ---------- + [1] S.R. Wenham, M.A. Green, M.E. Watt, "Applied Photovoltaics" ISBN + 0 86758 909 4 + [2] C. B. Jones, C. W. Hansen, Single Diode Parameter Extraction from + In-Field Photovoltaic I-V Curves on a Single Board Computer, 46th IEEE + Photovoltaic Specialist Conference, Chicago, IL, 2019 + """ + + # If not provided, extract v_oc, i_sc, v_mp and i_mp from the IV curve data + if v_oc is None: + v_oc = voltage[-1] + if i_sc is None: + i_sc = current[0] + if v_mp_i_mp is not None: + v_mp, i_mp = v_mp_i_mp + else: + v_mp, i_mp = _find_mp(voltage, current) + + # Find beta0 and beta1 from linear portion of the IV curve + beta0, beta1 = _find_beta0_beta1(voltage, current, vlim, v_oc) + + # Find beta3 and beta4 from the exponential portion of the IV curve + beta3, beta4 = _find_beta3_beta4(voltage, current, beta0, beta1, ilim, + i_sc) + + # calculate single diode parameters from regression coefficients + return _calculate_sde_parameters(beta0, beta1, beta3, beta4, v_mp, i_mp, + v_oc) + + +def _find_mp(voltage, current): + """ + Finds voltage and current at maximum power point. + + Parameters + ---------- + voltage : ndarray + 1D array containing voltage at each point on the IV curve, increasing + from 0 to v_oc inclusive, of `float` type [V] + + current : ndarray + 1D array containing current at each point on the IV curve, decreasing + from i_sc to 0 inclusive, of `float` type [A] + + Returns + ------- + v_mp, i_mp : tuple + voltage ``v_mp`` and current ``i_mp`` at the maximum power point [V], + [A] + """ + p = voltage * current + idx = np.argmax(p) + return voltage[idx], current[idx] + + +def _calc_I0(IL, I, V, Gp, Rs, nNsVth): + return (IL - I - Gp * V - Gp * Rs * I) / np.exp((V + Rs * I) / nNsVth) + + +def _find_beta0_beta1(v, i, vlim, v_oc): + # Get intercept and slope of linear portion of IV curve. + # Start with V =< vlim * v_oc, extend by adding points until slope is + # negative (downward). + beta0 = np.nan + beta1 = np.nan + first_idx = np.searchsorted(v, vlim * v_oc) + for idx in range(first_idx, len(v)): + coef = np.polyfit(v[:idx], i[:idx], deg=1) + if coef[0] < 0: + # intercept term + beta0 = coef[1].item() + # sign change of slope to get positive parameter value + beta1 = -coef[0].item() + break + if any(np.isnan([beta0, beta1])): + raise RuntimeError("Parameter extraction failed: beta0={}, beta1={}" + .format(beta0, beta1)) + else: + return beta0, beta1 + + +def _find_beta3_beta4(voltage, current, beta0, beta1, ilim, i_sc): + # Subtract the IV curve from the linear fit. + y = beta0 - beta1 * voltage - current + x = np.array([np.ones_like(voltage), voltage, current]).T + # Select points where y > ilim * i_sc to regress log(y) onto x + idx = (y > ilim * i_sc) + result = np.linalg.lstsq(x[idx], np.log(y[idx]), rcond=None) + coef = result[0] + beta3 = coef[1].item() + beta4 = coef[2].item() + if any(np.isnan([beta3, beta4])): + raise RuntimeError("Parameter extraction failed: beta3={}, beta4={}" + .format(beta3, beta4)) + else: + return beta3, beta4 + + +def _calculate_sde_parameters(beta0, beta1, beta3, beta4, v_mp, i_mp, v_oc): + nNsVth = 1.0 / beta3 + Rs = beta4 / beta3 + Gp = beta1 / (1.0 - Rs * beta1) + Rsh = 1.0 / Gp + IL = (1 + Gp * Rs) * beta0 + # calculate I0 + I0_vmp = _calc_I0(IL, i_mp, v_mp, Gp, Rs, nNsVth) + I0_voc = _calc_I0(IL, 0, v_oc, Gp, Rs, nNsVth) + if any(np.isnan([I0_vmp, I0_voc])) or ((I0_vmp <= 0) and (I0_voc <= 0)): + raise RuntimeError("Parameter extraction failed: I0 is undetermined.") + elif (I0_vmp > 0) and (I0_voc > 0): + I0 = 0.5 * (I0_vmp + I0_voc) + elif (I0_vmp > 0): + I0 = I0_vmp + else: # I0_voc > 0 + I0 = I0_voc + return (IL, I0, Rsh, Rs, nNsVth) diff --git a/setup.py b/setup.py index f2e320ccbb..a492b695e8 100755 --- a/setup.py +++ b/setup.py @@ -44,8 +44,8 @@ TESTS_REQUIRE = ['nose', 'pytest', 'pytest-cov', 'pytest-mock', 'pytest-timeout'] EXTRAS_REQUIRE = { - 'optional': ['ephem', 'cython', 'netcdf4', 'numba', 'pvfactors', 'scipy', - 'siphon', 'tables'], + 'optional': ['ephem', 'cython', 'netcdf4', 'nrel-pysam', 'numba', + 'pvfactors', 'scipy', 'siphon', 'tables'], 'doc': ['ipython', 'matplotlib', 'sphinx', 'sphinx_rtd_theme'], 'test': TESTS_REQUIRE }	diff --git a/pvlib/test/conftest.py b/pvlib/test/conftest.py index 1c690c2555..8789bf99f4 100644 --- a/pvlib/test/conftest.py +++ b/pvlib/test/conftest.py @@ -151,6 +151,15 @@ def has_numba(): reason='requires pvfactors') +try: + import PySAM # noqa: F401 + has_pysam = True +except ImportError: + has_pysam = False + +requires_pysam = pytest.mark.skipif(not has_pysam, reason="requires PySAM") + + @pytest.fixture(scope="session") def sam_data(): data = {} diff --git a/pvlib/test/test_ivtools.py b/pvlib/test/test_ivtools.py new file mode 100644 index 0000000000..d4aca050c4 --- /dev/null +++ b/pvlib/test/test_ivtools.py @@ -0,0 +1,242 @@ +# -- coding: utf-8 -- +""" +Created on Thu May 9 10:51:15 2019 + +@author: cwhanse +""" + +import numpy as np +import pandas as pd +import pytest +from pvlib import pvsystem +from pvlib import ivtools +from pvlib.test.conftest import requires_scipy, requires_pysam + + +@pytest.fixture +def get_test_iv_params(): + return {'IL': 8.0, 'I0': 5e-10, 'Rsh': 1000, 'Rs': 0.2, 'nNsVth': 1.61864} + + +@pytest.fixture +def get_cec_params_cansol_cs5p_220p(): + return {'input': {'V_mp_ref': 46.6, 'I_mp_ref': 4.73, 'V_oc_ref': 58.3, + 'I_sc_ref': 5.05, 'alpha_sc': 0.0025, + 'beta_voc': -0.19659, 'gamma_pmp': -0.43, + 'cells_in_series': 96}, + 'output': {'a_ref': 2.3674, 'I_L_ref': 5.056, 'I_o_ref': 1.01e-10, + 'R_sh_ref': 837.51, 'R_s': 1.004, 'Adjust': 2.3}} + + +@requires_scipy +def test_fit_sde_sandia(get_test_iv_params, get_bad_iv_curves): + test_params = get_test_iv_params + testcurve = pvsystem.singlediode(photocurrent=test_params['IL'], + saturation_current=test_params['I0'], + resistance_shunt=test_params['Rsh'], + resistance_series=test_params['Rs'], + nNsVth=test_params['nNsVth'], + ivcurve_pnts=300) + expected = tuple(test_params[k] for k in ['IL', 'I0', 'Rsh', 'Rs', + 'nNsVth']) + result = ivtools.fit_sde_sandia(voltage=testcurve['v'], + current=testcurve['i']) + assert np.allclose(result, expected, rtol=5e-5) + result = ivtools.fit_sde_sandia(voltage=testcurve['v'], + current=testcurve['i'], + v_oc=testcurve['v_oc'], + i_sc=testcurve['i_sc']) + assert np.allclose(result, expected, rtol=5e-5) + result = ivtools.fit_sde_sandia(voltage=testcurve['v'], + current=testcurve['i'], + v_oc=testcurve['v_oc'], + i_sc=testcurve['i_sc'], + v_mp_i_mp=(testcurve['v_mp'], + testcurve['i_mp'])) + assert np.allclose(result, expected, rtol=5e-5) + result = ivtools.fit_sde_sandia(voltage=testcurve['v'], + current=testcurve['i'], vlim=0.1) + assert np.allclose(result, expected, rtol=5e-5) + + +@requires_scipy +def test_fit_sde_sandia_bad_iv(get_bad_iv_curves): + # bad IV curves for coverage of if/then in _calculate_sde_parameters + v1, i1, v2, i2 = get_bad_iv_curves + result = ivtools.fit_sde_sandia(voltage=v1, current=i1) + assert np.allclose(result, (-2.4322856072799985, 8.854688976836396, + -63.56227601452038, 111.18558915546389, + -137.9965046659527)) + result = ivtools.fit_sde_sandia(voltage=v2, current=i2) + assert np.allclose(result, (2.62405311949227, 1.8657963912925288, + 110.35202827739991, -65.652554411442, + 174.49362093001415)) + + +@requires_pysam +def test_fit_sdm_cec_sam(get_cec_params_cansol_cs5p_220p): + input_data = get_cec_params_cansol_cs5p_220p['input'] + I_L_ref, I_o_ref, R_sh_ref, R_s, a_ref, Adjust = \ + ivtools.fit_sdm_cec_sam( + celltype='polySi', v_mp=input_data['V_mp_ref'], + i_mp=input_data['I_mp_ref'], v_oc=input_data['V_oc_ref'], + i_sc=input_data['I_sc_ref'], alpha_sc=input_data['alpha_sc'], + beta_voc=input_data['beta_voc'], + gamma_pmp=input_data['gamma_pmp'], + cells_in_series=input_data['cells_in_series']) + expected = pd.Series(get_cec_params_cansol_cs5p_220p['output']) + modeled = pd.Series(index=expected.index, data=np.nan) + modeled['a_ref'] = a_ref + modeled['I_L_ref'] = I_L_ref + modeled['I_o_ref'] = I_o_ref + modeled['R_sh_ref'] = R_sh_ref + modeled['R_s'] = R_s + modeled['Adjust'] = Adjust + assert np.allclose(modeled.values, expected.values, rtol=5e-2) + # test for fitting failure + with pytest.raises(RuntimeError): + I_L_ref, I_o_ref, R_sh_ref, R_s, a_ref, Adjust = \ + ivtools.fit_sdm_cec_sam( + celltype='polySi', v_mp=0.45, i_mp=5.25, v_oc=0.55, i_sc=5.5, + alpha_sc=0.00275, beta_voc=0.00275, gamma_pmp=0.0055, + cells_in_series=1, temp_ref=25) + + +@pytest.fixture +def get_bad_iv_curves(): + # v1, i1 produces a bad value for I0_voc + v1 = np.array([0, 0.338798867469060, 0.677597734938121, 1.01639660240718, + 1.35519546987624, 1.69399433734530, 2.03279320481436, + 2.37159207228342, 2.71039093975248, 3.04918980722154, + 3.38798867469060, 3.72678754215966, 4.06558640962873, + 4.40438527709779, 4.74318414456685, 5.08198301203591, + 5.42078187950497, 5.75958074697403, 6.09837961444309, + 6.43717848191215, 6.77597734938121, 7.11477621685027, + 7.45357508431933, 7.79237395178839, 8.13117281925745, + 8.46997168672651, 8.80877055419557, 9.14756942166463, + 9.48636828913369, 9.82516715660275, 10.1639660240718, + 10.5027648915409, 10.8415637590099, 11.1803626264790, + 11.5191614939481, 11.8579603614171, 12.1967592288862, + 12.5355580963552, 12.8743569638243, 13.2131558312934, + 13.5519546987624, 13.8907535662315, 14.2295524337005, + 14.5683513011696, 14.9071501686387, 15.2459490361077, + 15.5847479035768, 15.9235467710458, 16.2623456385149, + 16.6011445059840, 16.9399433734530, 17.2787422409221, + 17.6175411083911, 17.9563399758602, 18.2951388433293, + 18.6339377107983, 18.9727365782674, 19.3115354457364, + 19.6503343132055, 19.9891331806746, 20.3279320481436, + 20.6667309156127, 21.0055297830817, 21.3443286505508, + 21.6831275180199, 22.0219263854889, 22.3607252529580, + 22.6995241204270, 23.0383229878961, 23.3771218553652, + 23.7159207228342, 24.0547195903033, 24.3935184577724, + 24.7323173252414, 25.0711161927105, 25.4099150601795, + 25.7487139276486, 26.0875127951177, 26.4263116625867, + 26.7651105300558, 27.1039093975248, 27.4427082649939, + 27.7815071324630, 28.1203059999320, 28.4591048674011, + 28.7979037348701, 29.1367026023392, 29.4755014698083, + 29.8143003372773, 30.1530992047464, 30.4918980722154, + 30.8306969396845, 31.1694958071536, 31.5082946746226, + 31.8470935420917, 32.1858924095607, 32.5246912770298, + 32.8634901444989, 33.2022890119679, 33.5410878794370]) + i1 = np.array([3.39430882774470, 2.80864492110761, 3.28358165429196, + 3.41191190551673, 3.11975662808148, 3.35436585834612, + 3.23953272899809, 3.60307083325333, 2.80478101508277, + 2.80505102853845, 3.16918996870373, 3.21088388439857, + 3.46332865310431, 3.09224155015883, 3.17541550741062, + 3.32470179290389, 3.33224664316240, 3.07709000050741, + 2.89141245343405, 3.01365768561537, 3.23265176770231, + 3.32253647634228, 2.97900657569736, 3.31959549243966, + 3.03375461550111, 2.97579298978937, 3.25432831375159, + 2.89178382564454, 3.00341909207567, 3.72637492250097, + 3.28379856976360, 2.96516169245835, 3.25658381110230, + 3.41655911533139, 3.02718097944604, 3.11458376760376, + 3.24617304369762, 3.45935502367636, 3.21557333256913, + 3.27611176482650, 2.86954135732485, 3.32416319254657, + 3.15277467598732, 3.08272557013770, 3.15602202666259, + 3.49432799877150, 3.53863997177632, 3.10602611478455, + 3.05373911151821, 3.09876772570781, 2.97417228624287, + 2.84573593699237, 3.16288578405195, 3.06533173612783, + 3.02118336639575, 3.34374977225502, 2.97255164138821, + 3.19286135682863, 3.10999753817133, 3.26925354620079, + 3.11957809501529, 3.20155017481720, 3.31724984405837, + 3.42879043512927, 3.17933067619240, 3.47777362613969, + 3.20708912539777, 3.48205761174907, 3.16804363684327, + 3.14055472378230, 3.13445657434470, 2.91152696252998, + 3.10984113847427, 2.80443349399489, 3.23146278164875, + 2.94521083406108, 3.17388903141715, 3.05930294897030, + 3.18985234673287, 3.27946609274898, 3.33717523113602, + 2.76394303462702, 3.19375132937510, 2.82628616689450, + 2.85238527394143, 2.82975892599489, 2.79196912313914, + 2.72860792049395, 2.75585977414140, 2.44280222448805, + 2.36052347370628, 2.26785071765738, 2.10868255743462, + 2.06165739407987, 1.90047259509385, 1.39925575828709, + 1.24749015957606, 0.867823806536762, 0.432752457749993, 0]) + # v2, i2 produces a bad value for I0_vmp + v2 = np.array([0, 0.365686097622586, 0.731372195245173, 1.09705829286776, + 1.46274439049035, 1.82843048811293, 2.19411658573552, + 2.55980268335810, 2.92548878098069, 3.29117487860328, + 3.65686097622586, 4.02254707384845, 4.38823317147104, + 4.75391926909362, 5.11960536671621, 5.48529146433880, + 5.85097756196138, 6.21666365958397, 6.58234975720655, + 6.94803585482914, 7.31372195245173, 7.67940805007431, + 8.04509414769690, 8.41078024531949, 8.77646634294207, + 9.14215244056466, 9.50783853818725, 9.87352463580983, + 10.2392107334324, 10.6048968310550, 10.9705829286776, + 11.3362690263002, 11.7019551239228, 12.0676412215454, + 12.4333273191679, 12.7990134167905, 13.1646995144131, + 13.5303856120357, 13.8960717096583, 14.2617578072809, + 14.6274439049035, 14.9931300025260, 15.3588161001486, + 15.7245021977712, 16.0901882953938, 16.4558743930164, + 16.8215604906390, 17.1872465882616, 17.5529326858841, + 17.9186187835067, 18.2843048811293, 18.6499909787519, + 19.0156770763745, 19.3813631739971, 19.7470492716197, + 20.1127353692422, 20.4784214668648, 20.8441075644874, + 21.2097936621100, 21.5754797597326, 21.9411658573552, + 22.3068519549778, 22.6725380526004, 23.0382241502229, + 23.4039102478455, 23.7695963454681, 24.1352824430907, + 24.5009685407133, 24.8666546383359, 25.2323407359585, + 25.5980268335810, 25.9637129312036, 26.3293990288262, + 26.6950851264488, 27.0607712240714, 27.4264573216940, + 27.7921434193166, 28.1578295169392, 28.5235156145617, + 28.8892017121843, 29.2548878098069, 29.6205739074295, + 29.9862600050521, 30.3519461026747, 30.7176322002973, + 31.0833182979198, 31.4490043955424, 31.8146904931650, + 32.1803765907876, 32.5460626884102, 32.9117487860328, + 33.2774348836554, 33.6431209812779, 34.0088070789005, + 34.3744931765231, 34.7401792741457, 35.1058653717683, + 35.4715514693909, 35.8372375670135, 36.2029236646360]) + i2 = np.array([6.49218806928330, 6.49139336899548, 6.17810697175204, + 6.75197816263663, 6.59529074137515, 6.18164578868300, + 6.38709397931910, 6.30685422248427, 6.44640615548925, + 6.88727230397772, 6.42074852785591, 6.46348580823746, + 6.38642309763941, 5.66356277572311, 6.61010381702082, + 6.33288284311125, 6.22475343933610, 6.30651399433833, + 6.44435022944051, 6.43741711131908, 6.03536180208946, + 6.23814639328170, 5.97229140403242, 6.20790000748341, + 6.22933550182341, 6.22992127804882, 6.13400871899299, + 6.83491312449950, 6.07952797245846, 6.35837746415450, + 6.41972128662324, 6.85256717258275, 6.25807797296759, + 6.25124948151766, 6.22229212812413, 6.72249444167406, + 6.41085549981649, 6.75792874870056, 6.22096181559171, + 6.47839564388996, 6.56010208597432, 6.63300966556949, + 6.34617546039339, 6.79812221146153, 6.14486056194136, + 6.14979256889311, 6.16883037644880, 6.57309183229605, + 6.40064681038509, 6.18861448239873, 6.91340138179698, + 5.94164388433788, 6.23638991745862, 6.31898940411710, + 6.45247884556830, 6.58081455524297, 6.64915284801713, + 6.07122119270245, 6.41398258148256, 6.62144271089614, + 6.36377197712687, 6.51487678829345, 6.53418950147730, + 6.18886469125371, 6.26341063475750, 6.83488211680259, + 6.62699397226695, 6.41286837534735, 6.44060085001851, + 6.48114130629288, 6.18607038456406, 6.16923370572396, + 6.64223126283631, 6.07231852289266, 5.79043710204375, + 6.48463886529882, 6.36263392044401, 6.11212476454494, + 6.14573900812925, 6.12568047243240, 6.43836230231577, + 6.02505694060219, 6.13819468942244, 6.22100593815064, + 6.02394682666345, 5.89016573063789, 5.74448527739202, + 5.50415294280017, 5.31883018164157, 4.87476769510305, + 4.74386713755523, 4.60638346931628, 4.06177345572680, + 3.73334482123538, 3.13848311672243, 2.71638862600768, + 2.02963773590165, 1.49291145092070, 0.818343889647352, 0]) + + return v1, i1, v2, i2	diff --git a/ci/requirements-py35.yml b/ci/requirements-py35.yml index 65b5c76d00..5fc0077991 100644 --- a/ci/requirements-py35.yml +++ b/ci/requirements-py35.yml @@ -24,4 +24,5 @@ dependencies: - shapely # pvfactors dependency - siphon # conda-forge - pip: + - nrel-pysam - pvfactors==1.0.1 diff --git a/ci/requirements-py36.yml b/ci/requirements-py36.yml index a21bce2579..e415f67c7d 100644 --- a/ci/requirements-py36.yml +++ b/ci/requirements-py36.yml @@ -24,4 +24,5 @@ dependencies: - shapely # pvfactors dependency - siphon # conda-forge - pip: + - nrel-pysam - pvfactors==1.0.1 diff --git a/ci/requirements-py37.yml b/ci/requirements-py37.yml index 3783e8f772..1a6809fba6 100644 --- a/ci/requirements-py37.yml +++ b/ci/requirements-py37.yml @@ -24,4 +24,5 @@ dependencies: - shapely # pvfactors dependency - siphon # conda-forge - pip: + - nrel-pysam - pvfactors==1.0.1 diff --git a/docs/sphinx/source/api.rst b/docs/sphinx/source/api.rst index 8af2bf0f40..6e93dc5807 100644 --- a/docs/sphinx/source/api.rst +++ b/docs/sphinx/source/api.rst @@ -294,6 +294,14 @@ PVWatts model pvsystem.pvwatts_losses pvsystem.pvwatts_losses +Functions for fitting PV models +------------------------------- +.. autosummary:: + :toctree: generated/ + + ivtools.fit_sde_sandia + ivtools.fit_sdm_cec_sam + Other ----- diff --git a/docs/sphinx/source/whatsnew/v0.7.0.rst b/docs/sphinx/source/whatsnew/v0.7.0.rst index d9045a5cfb..9405eac906 100644 --- a/docs/sphinx/source/whatsnew/v0.7.0.rst +++ b/docs/sphinx/source/whatsnew/v0.7.0.rst @@ -104,6 +104,26 @@ Documentation ~~~~~~~~~~~~~ * Corrected docstring for `pvsystem.PVSystem.sapm` +API Changes +~~~~~~~~~~~ + + +Enhancements +~~~~~~~~~~~~ +* Add `ivtools` module to contain functions for IV model fitting. +* Add :py:func:`~pvlib.ivtools.fit_sde_sandia`, a simple method to fit + the single diode equation to an IV curve. +* Add :py:func:`~pvlib.ivtools.fit_sdm_cec_sam`, a wrapper for the CEC single + diode model fitting function '6parsolve' from NREL's System Advisor Model. + + +Bug fixes +~~~~~~~~~ + + +Testing +~~~~~~~ + Removal of prior version deprecations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * Removed `irradiance.extraradiation`. @@ -119,6 +139,7 @@ Contributors ~~~~~~~~~~~~ * Mark Campanellli (:ghuser:`markcampanelli`) * Will Holmgren (:ghuser:`wholmgren`) +* Cliff Hansen (:ghuser:`cwhanse`) * Oscar Dowson (:ghuser:`odow`) * Anton Driesse (:ghuser:`adriesse`) * Alexander Morgan (:ghuser:`alexandermorgan`)	[ { "components": [ { "doc": "Estimates parameters for the CEC single diode model (SDM) using the SAM\nSDK.\n\nParameters\n----------\ncelltype : str\n Value is one of 'monoSi', 'multiSi', 'polySi', 'cis', 'cigs', 'cdte',\n 'amorphous'\nv_mp : float\n Voltage at maximum power point [V]\ni_m...	[ "pvlib/test/test_ivtools.py::test_fit_sde_sandia", "pvlib/test/test_ivtools.py::test_fit_sde_sandia_bad_iv" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Create ivtools pvlib python pull request guidelines ==================================== Thank you for your contribution to pvlib python! You may delete all of these instructions except for the list below. You may submit a pull request with your code at any stage of completion. The following items must be addressed before the code can be merged. Please don't hesitate to ask for help if you're unsure of how to accomplish any of the items below: - [x] Closes #511 - [x] I am familiar with the [contributing guidelines](http://pvlib-python.readthedocs.io/en/latest/contributing.html). - [x] Fully tested. Added and/or modified tests to ensure correct behavior for all reasonable inputs. Tests (usually) must pass on the TravisCI and Appveyor testing services. - [x] Updates entries to `docs/sphinx/source/api.rst` for API changes. - [x] Adds description and name entries in the appropriate `docs/sphinx/source/whatsnew` file for all changes. - [x] Code quality and style is sufficient. Passes LGTM and SticklerCI checks. - [x] New code is fully documented. Includes sphinx/numpydoc compliant docstrings and comments in the code where necessary. - [x] Pull request is nearly complete and ready for detailed review. Brief description of the problem and proposed solution (if not already fully described in the issue linked to above): Add module ivtools with code to fit diode models and diode equations using IV curve data. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pvlib/ivtools.py] (definition of fit_sdm_cec_sam:) def fit_sdm_cec_sam(celltype, v_mp, i_mp, v_oc, i_sc, alpha_sc, beta_voc, gamma_pmp, cells_in_series, temp_ref=25): """Estimates parameters for the CEC single diode model (SDM) using the SAM SDK. Parameters ---------- celltype : str Value is one of 'monoSi', 'multiSi', 'polySi', 'cis', 'cigs', 'cdte', 'amorphous' v_mp : float Voltage at maximum power point [V] i_mp : float Current at maximum power point [A] v_oc : float Open circuit voltage [V] i_sc : float Short circuit current [A] alpha_sc : float Temperature coefficient of short circuit current [A/C] beta_voc : float Temperature coefficient of open circuit voltage [V/C] gamma_pmp : float Temperature coefficient of power at maximum point point [%/C] cells_in_series : int Number of cells in series temp_ref : float, default 25 Reference temperature condition [C] Returns ------- tuple of the following elements: * I_L_ref : float The light-generated current (or photocurrent) at reference conditions [A] * I_o_ref : float The dark or diode reverse saturation current at reference conditions [A] * R_sh_ref : float The shunt resistance at reference conditions, in ohms. * R_s : float The series resistance at reference conditions, in ohms. * a_ref : float The product of the usual diode ideality factor ``n`` (unitless), number of cells in series ``Ns``, and cell thermal voltage at reference conditions [V] * Adjust : float The adjustment to the temperature coefficient for short circuit current, in percent. Raises ------ ImportError if NREL-PySAM is not installed. RuntimeError if parameter extraction is not successful. Notes ----- Inputs ``v_mp``, ``v_oc``, ``i_mp`` and ``i_sc`` are assumed to be from a single IV curve at constant irradiance and cell temperature. Irradiance is not explicitly used by the fitting procedure. The irradiance level at which the input IV curve is determined and the specified cell temperature ``temp_ref`` are the reference conditions for the output parameters ``I_L_ref``, ``I_o_ref``, ``R_sh_ref``, ``R_s``, ``a_ref`` and ``Adjust``. References ---------- [1] A. Dobos, "An Improved Coefficient Calculator for the California Energy Commission 6 Parameter Photovoltaic Module Model", Journal of Solar Energy Engineering, vol 134, 2012.""" (definition of fit_sde_sandia:) def fit_sde_sandia(voltage, current, v_oc=None, i_sc=None, v_mp_i_mp=None, vlim=0.2, ilim=0.1): """Fits the single diode equation (SDE) to an IV curve. Parameters ---------- voltage : ndarray 1D array of `float` type containing voltage at each point on the IV curve, increasing from 0 to ``v_oc`` inclusive [V] current : ndarray 1D array of `float` type containing current at each point on the IV curve, from ``i_sc`` to 0 inclusive [A] v_oc : float, default None Open circuit voltage [V]. If not provided, ``v_oc`` is taken as the last point in the ``voltage`` array. i_sc : float, default None Short circuit current [A]. If not provided, ``i_sc`` is taken as the first point in the ``current`` array. v_mp_i_mp : tuple of float, default None Voltage, current at maximum power point in units of [V], [A]. If not provided, the maximum power point is found at the maximum of ``voltage`` \times ``current``. vlim : float, default 0.2 Defines portion of IV curve where the exponential term in the single diode equation can be neglected, i.e. ``voltage`` <= ``vlim`` x ``v_oc`` [V] ilim : float, default 0.1 Defines portion of the IV curve where the exponential term in the single diode equation is signficant, approximately defined by ``current`` < (1 - ``ilim``) x ``i_sc`` [A] Returns ------- tuple of the following elements: * photocurrent : float photocurrent [A] * saturation_current : float dark (saturation) current [A] * resistance_shunt : float shunt (parallel) resistance, in ohms * resistance_series : float series resistance, in ohms * nNsVth : float product of thermal voltage ``Vth`` [V], diode ideality factor ``n``, and number of series cells ``Ns`` Raises ------ RuntimeError if parameter extraction is not successful. Notes ----- Inputs ``voltage``, ``current``, ``v_oc``, ``i_sc`` and ``v_mp_i_mp`` are assumed to be from a single IV curve at constant irradiance and cell temperature. :py:func:`fit_single_diode_sandia` obtains values for the five parameters for the single diode equation [1]: .. math:: I = I_{L} - I_{0} (\exp \frac{V + I R_{s}}{nNsVth} - 1) - \frac{V + I R_{s}}{R_{sh}} See :py:func:`pvsystem.singlediode` for definition of the parameters. The extraction method [2] proceeds in six steps. 1. In the single diode equation, replace :math:`R_{sh} = 1/G_{p}` and re-arrange .. math:: I = \frac{I_{L}}{1 + G_{p} R_{s}} - \frac{G_{p} V}{1 + G_{p} R_{s}} - \frac{I_{0}}{1 + G_{p} R_{s}} (\exp(\frac{V + I R_{s}}{nNsVth}) - 1) 2. The linear portion of the IV curve is defined as :math:`V \le vlim \times v_oc`. Over this portion of the IV curve, .. math:: \frac{I_{0}}{1 + G_{p} R_{s}} (\exp(\frac{V + I R_{s}}{nNsVth}) - 1) \approx 0 3. Fit the linear portion of the IV curve with a line. .. math:: I &\approx \frac{I_{L}}{1 + G_{p} R_{s}} - \frac{G_{p} V}{1 + G_{p} R_{s}} \\ &= \beta_{0} + \beta_{1} V 4. The exponential portion of the IV curve is defined by :math:`\beta_{0} + \beta_{1} \times V - I > ilim \times i_sc`. Over this portion of the curve, :math:`exp((V + IRs)/nNsVth) >> 1` so that .. math:: \exp(\frac{V + I R_{s}}{nNsVth}) - 1 \approx \exp(\frac{V + I R_{s}}{nNsVth}) 5. Fit the exponential portion of the IV curve. .. math:: \log(\beta_{0} - \beta_{1} V - I) &\approx \log(\frac{I_{0}}{1 + G_{p} R_{s}} + \frac{V}{nNsVth} + \frac{I R_{s}}{nNsVth} \\ &= \beta_{2} + beta_{3} V + \beta_{4} I 6. Calculate values for ``IL, I0, Rs, Rsh,`` and ``nNsVth`` from the regression coefficents :math:`\beta_{0}, \beta_{1}, \beta_{3}` and :math:`\beta_{4}`. References ---------- [1] S.R. Wenham, M.A. Green, M.E. Watt, "Applied Photovoltaics" ISBN 0 86758 909 4 [2] C. B. Jones, C. W. Hansen, Single Diode Parameter Extraction from In-Field Photovoltaic I-V Curves on a Single Board Computer, 46th IEEE Photovoltaic Specialist Conference, Chicago, IL, 2019""" (definition of _find_mp:) def _find_mp(voltage, current): """Finds voltage and current at maximum power point. Parameters ---------- voltage : ndarray 1D array containing voltage at each point on the IV curve, increasing from 0 to v_oc inclusive, of `float` type [V] current : ndarray 1D array containing current at each point on the IV curve, decreasing from i_sc to 0 inclusive, of `float` type [A] Returns ------- v_mp, i_mp : tuple voltage ``v_mp`` and current ``i_mp`` at the maximum power point [V], [A]""" (definition of _calc_I0:) def _calc_I0(IL, I, V, Gp, Rs, nNsVth): (definition of _find_beta0_beta1:) def _find_beta0_beta1(v, i, vlim, v_oc): (definition of _find_beta3_beta4:) def _find_beta3_beta4(voltage, current, beta0, beta1, ilim, i_sc): (definition of _calculate_sde_parameters:) def _calculate_sde_parameters(beta0, beta1, beta3, beta4, v_mp, i_mp, v_oc): [end of new definitions in pvlib/ivtools.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> CEC 6-parameter coefficient generation SAM is able to extract the CEC parameters required for calcparams_desoto. This is done through the 'CEC Performance Model with User Entered Specifications' module model, and coefficients are automatically extracted given nameplate parameters Voc, Isc, Imp, Vmp and TempCoeff. The method is based on Aron Dobos' "An Improved Coefficient Calculator for the California Energy Commission 6 Parameter Photovoltaic Module Model ", 2012 Ideally we should be able to work with the SAM open source code, extract the bit that does the coefficient generation, and put it into a PVLib function that would allow users to run calcparams_desoto with any arbitrary module type. At the moment we are dependent on PV modules loaded into the SAM or CEC database. Thank you! ---------- SAM solution routine is located at https://github.com/NREL/ssc/blob/develop/shared/6par_solve.h , function "solve_with_sanity_and_heuristics" . Additional dependencies on other files 6par_newton.h, 6par_search.h, 6par_jacobian.h, 6par_lu.h, 6par_gamma.h, all located in https://github.com/NREL/ssc/tree/develop/shared . I'd like to try to take this up sometime soon, maybe by the end of the year? Is anyone else working on it? I haven't seen a PR. Does anyone have any strong opinions? Is seems like there's a SAM implementation, is there a PVLIB-MATLAB version already? thx I'm not working on it. If it is practical, it would be great to wrap the SAM method. NREL put a lot of effort into the heuristics for initial values and updating. We have a function in PVLib for MATLAB but it's a very different algorithm. For consistency with the parameter databases it would be better to use the SAM algorithm. Do I read between the lines that the two algorithms do not converge on the same parameters? Then it would be of great interest to have python implementations of each! Or perhaps even more important: documents describing the full algorithms along with every heuristic, assumption and constraint they implement... @adriesse yes. Each model fitting algorithm I'm aware of, will produce different parameter values from the same data although the predicted IV curves may be similar. FWIW I am trying to establish a common/fair metric to compare different model fits in PVfit. In addition to choosing, say, which residual(s) to analyze, the effect of model discrepancy significantly affects such comparisons. PVfit’s orthogonal distance regression (ODR) fits to the single-diode model (SDM) often are worse than other algorithms’ fits in terms of terminal current residuals, but I have observed consistently that this is likely due to model discrepancy. One might claim that ODR is being more “honest” here, but I think it really means that the model should be improved. Note that PVfit’s ODR alternatively optimizes the residual of the sum of currents at the high-voltage diode node in the equivalent-circuit model, and it doesn’t make unfounded assumptions about error-free measurements in all data channels except the terminal current (which also has implications for parameter non-identifiability). I have seen plenty of evidence that ODR fits are “good” in the absence of significant model discrepancy, such as for some (but not all!) double-diode model (DDM) fits across various material systems. > If it is practical, it would be great to wrap the SAM method. Two kinds of practicalities here: 1. Technical. I don't know how to do it but I am sure it's possible. I am ok with it so long as pvlib remains straightforward to install from source. 2. Legal. We would need assurance from NREL that it's ok for pvlib to distribute this SAM code under the terms of a MIT license rather than SAM's mixed MIT/GPL license. In the next 6-8 months, the NREL team will be updating our python wrapper for the SAM software development kit so that you can pip install the sam-sdk and call its routines in a much more native pythonic fashion. That might be a quick way to implement the CEC parameter generation to solve both the technical and legal practicalities Will mentions above, as well as the many file dependencies involved with that routine. The SDK is licensed separately from the SAM open source code under an MIT type license, so that distribution with pvlib would be ok, and once we have it set up as a python package, that should make it a non-issue to include with pvlib installation from source. To @adriesse 's point, the publication associated with the method implemented in SAM is here: http://solarenergyengineering.asmedigitalcollection.asme.org/article.aspx?articleid=1458865 Thanks @janinefreeman that is great news! @janinefreeman Does NREL's web site no longer provide free preprints of Aron's paper? @thunderfish24 I'm not finding a copy of it in NREL's pubs database, but it looks like you may be able to get it here (didn't create an account to give it a try): https://www.osti.gov/biblio/1043759 @thunderfish24 I sent you a preprint. -------------------- </issues>	3c84edd644fa4db54955e2225a183fa3e0405eb0
sympy__sympy-16825	16,825	sympy/sympy	1.5	6ffc2f04ad820e3f592b2107e66a16fd4585ac02	2019-05-13T12:06:41Z	diff --git a/sympy/stats/joint_rv_types.py b/sympy/stats/joint_rv_types.py index 224e3f0b9230..f7614a0beb81 100644 --- a/sympy/stats/joint_rv_types.py +++ b/sympy/stats/joint_rv_types.py @@ -1,6 +1,7 @@ from sympy import (sympify, S, pi, sqrt, exp, Lambda, Indexed, Gt, IndexedBase, besselk, gamma, Interval, Range, factorial, Mul, Integer, - Add, rf, Eq, Piecewise, Symbol, imageset, Intersection) + Add, rf, Eq, Piecewise, ones, Symbol, Pow, Rational, Sum, + imageset, Intersection, Matrix) from sympy.matrices import ImmutableMatrix from sympy.matrices.expressions.determinant import det from sympy.stats.joint_rv import (JointDistribution, JointPSpace, @@ -394,6 +395,161 @@ def MultivariateEwens(syms, n, theta): """ return multivariate_rv(MultivariateEwensDistribution, syms, n, theta) +#------------------------------------------------------------------------------- +# Generalized Multivariate Log Gamma distribution --------------------------------------------------------- + +class GeneralizedMultivariateLogGammaDistribution(JointDistribution): + + _argnames = ['delta', 'v', 'lamda', 'mu'] + is_Continuous=True + + def check(self, delta, v, l, mu): + _value_check((delta >= 0, delta <= 1), "delta must be in range [0, 1].") + _value_check((v > 0), "v must be positive") + for lk in l: + _value_check((lk > 0), "lamda must be a positive vector.") + for muk in mu: + _value_check((muk > 0), "mu must be a positive vector.") + _value_check(len(l) > 1,"the distribution should have at least" + " two random variables.") + + @property + def set(self): + from sympy.sets.sets import Interval + return S.Reals*len(self.lamda) + + def pdf(self, y): + from sympy.functions.special.gamma_functions import gamma + d, v, l, mu = self.delta, self.v, self.lamda, self.mu + n = Symbol('n', negative=False, integer=True) + k = len(l) + sterm1 = Pow((1 - d), n)/\ + ((gamma(v + n)*(k - 1))gamma(v)gamma(n + 1)) + sterm2 = Mul.fromiter([muili*(-v - n) for mui, li in zip(mu, l)]) + term1 = sterm1 sterm2 + sterm3 = (v + n) * sum([mui * yi for mui, yi in zip(mu, y)]) + sterm4 = sum([exp(mui * yi)/li for (mui, yi, li) in zip(mu, y, l)]) + term2 = exp(sterm3 - sterm4) + return Pow(d, v) * Sum(term1 * term2, (n, 0, S.Infinity)) + +def GeneralizedMultivariateLogGamma(syms, delta, v, lamda, mu): + """ + Creates a joint random variable with generalized multivariate log gamma + distribution. + + The joint pdf can be found at [1]. + + Parameters + ========== + + syms: list/tuple/set of symbols for identifying each component + delta: A constant in range [0, 1] + v: positive real + lamda: a list of positive reals + mu: a list of positive reals + + Returns + ======= + + A Random Symbol + + Examples + ======== + + >>> from sympy.stats import density + >>> from sympy.stats.joint_rv import marginal_distribution + >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma + >>> from sympy import symbols, S + >>> v = 1 + >>> l, mu = [1, 1, 1], [1, 1, 1] + >>> d = S.Half + >>> y = symbols('y_1:4', positive=True) + >>> Gd = GeneralizedMultivariateLogGamma('G', d, v, l, mu) + >>> density(Gd)(y[0], y[1], y[2]) + Sum(2*(-n)exp((n + 1)(y_1 + y_2 + y_3) - exp(y_1) - exp(y_2) - + exp(y_3))/gamma(n + 1)3, (n, 0, oo))/2 + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Generalized_multivariate_log-gamma_distribution + .. [2] https://www.researchgate.net/publication/234137346_On_a_multivariate_log-gamma_distribution_and_the_use_of_the_distribution_in_the_Bayesian_analysis + + Note + ==== + + If the GeneralizedMultivariateLogGamma is too long to type use, + `from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma as GMVLG` + If you want to pass the matrix omega instead of the constant delta, then use, + GeneralizedMultivariateLogGammaOmega. + + """ + return multivariate_rv(GeneralizedMultivariateLogGammaDistribution, + syms, delta, v, lamda, mu) + +def GeneralizedMultivariateLogGammaOmega(syms, omega, v, lamda, mu): + """ + Extends GeneralizedMultivariateLogGamma. + + Parameters + ========== + + syms: list/tuple/set of symbols for identifying each component + omega: A square matrix + Every element of square matrix must be absolute value of + sqaure root of correlation coefficient + v: positive real + lamda: a list of positive reals + mu: a list of positive reals + + Returns + ======= + + A Random Symbol + + Examples + ======== + + >>> from sympy.stats import density + >>> from sympy.stats.joint_rv import marginal_distribution + >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega + >>> from sympy import Matrix, symbols, S + >>> omega = Matrix([[1, S.Half, S.Half], [S.Half, 1, S.Half], [S.Half, S.Half, 1]]) + >>> v = 1 + >>> l, mu = [1, 1, 1], [1, 1, 1] + >>> G = GeneralizedMultivariateLogGammaOmega('G', omega, v, l, mu) + >>> y = symbols('y_1:4', positive=True) + >>> density(G)(y[0], y[1], y[2]) + sqrt(2)Sum((1 - sqrt(2)/2)*nexp((n + 1)(y_1 + y_2 + y_3) - exp(y_1) - + exp(y_2) - exp(y_3))/gamma(n + 1)*3, (n, 0, oo))/2 + + References + ========== + + See references of GeneralizedMultivariateLogGamma. + + Notes + ===== + + If the GeneralizedMultivariateLogGammaOmega is too long to type use, + `from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega as GMVLGO` + """ + _value_check((omega.is_square, isinstance(omega, Matrix)), "omega must be a" + " square matrix") + for val in omega.values(): + _value_check((val >= 0, val <= 1), + "all values in matrix must be between 0 and 1(both inclusive).") + _value_check(omega.diagonal().equals(ones(1, omega.shape[0])), + "all the elements of diagonal should be 1.") + _value_check((omega.shape[0] == len(lamda), len(lamda) == len(mu)), + "lamda, mu should be of same length and omega should " + " be of shape (length of lamda, length of mu)") + _value_check(len(lamda) > 1,"the distribution should have at least" + " two random variables.") + delta = Pow(Rational(omega.det()), Rational(1, len(lamda) - 1)) + return GeneralizedMultivariateLogGamma(syms, delta, v, lamda, mu) + + #------------------------------------------------------------------------------- # Multinomial distribution ---------------------------------------------------------	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 098a0a559ca2..722bf012b762 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1501,6 +1501,11 @@ def test_sympy__stats__joint_rv_types__NormalGammaDistribution(): from sympy.stats.joint_rv_types import NormalGammaDistribution assert _test_args(NormalGammaDistribution(1, 2, 3, 4)) +def test_sympy__stats__joint_rv_types__GeneralizedMultivariateLogGammaDistribution(): + from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaDistribution + v, l, mu = (4, [1, 2, 3, 4], [1, 2, 3, 4]) + assert _test_args(GeneralizedMultivariateLogGammaDistribution(S.Half, v, l, mu)) + def test_sympy__stats__joint_rv_types__MultivariateBetaDistribution(): from sympy.stats.joint_rv_types import MultivariateBetaDistribution assert _test_args(MultivariateBetaDistribution([1, 2, 3])) diff --git a/sympy/stats/tests/test_joint_rv.py b/sympy/stats/tests/test_joint_rv.py index 71f18a1123a0..0bb5ac95562c 100644 --- a/sympy/stats/tests/test_joint_rv.py +++ b/sympy/stats/tests/test_joint_rv.py @@ -1,5 +1,5 @@ -from sympy import (symbols, pi, oo, S, exp, sqrt, besselk, Indexed, Rational, - simplify, Piecewise, factorial, Eq, gamma, Sum) +from sympy import (symbols, pi, oo, S, exp, sqrt, besselk, Indexed, Sum, simplify, + Mul, Rational, Integral, factorial, gamma, Piecewise, Eq) from sympy.core.numbers import comp from sympy.stats import density from sympy.stats.joint_rv import marginal_distribution @@ -55,6 +55,68 @@ def test_NormalGamma(): 3sqrt(10)gamma(S(7)/4)/(10sqrt(pi)gamma(S(5)/4)) assert marginal_distribution(ng, y)(1) == exp(-S(1)/4)/128 +def test_GeneralizedMultivariateLogGammaDistribution(): + from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega as GMVLGO + from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma as GMVLG + from sympy import gamma + h = S.Half + omega = Matrix([[1, h, h, h], + [h, 1, h, h], + [h, h, 1, h], + [h, h, h, 1]]) + v, l, mu = (4, [1, 2, 3, 4], [1, 2, 3, 4]) + y_1, y_2, y_3, y_4 = symbols('y_1:5', real=True) + n = symbols('n', negative=False, integer=True) + delta = symbols('d', positive=True) + G = GMVLGO('G', omega, v, l, mu) + Gd = GMVLG('Gd', delta, v, l, mu) + dend = ("d*4Sum(424(-n - 4)(1 - d)*nexp((n + 4)(y_1 + 2y_2 + 3y_3 " + "+ 4y_4) - exp(y_1) - exp(2y_2)/2 - exp(3y_3)/3 - exp(4y_4)/4)/" + "(gamma(n + 1)gamma(n + 4)*3), (n, 0, oo))") + assert str(density(Gd)(y_1, y_2, y_3, y_4)) == dend + den = ("52*(2/3)5*(1/3)Sum(424(-n - 4)(-2*(2/3)5(1/3)/4 + 1)n" + "exp((n + 4)(y_1 + 2y_2 + 3y_3 + 4y_4) - exp(y_1) - exp(2y_2)/2 - " + "exp(3y_3)/3 - exp(4y_4)/4)/(gamma(n + 1)gamma(n + 4)3), (n, 0, oo))/64") + assert str(density(G)(y_1, y_2, y_3, y_4)) == den + marg = ("52*(2/3)5*(1/3)exp(4y_1)exp(-exp(y_1))Integral(exp(-exp(4G[3])" + "/4)exp(16G[3])Integral(exp(-exp(3G[2])/3)exp(12G[2])Integral(exp(" + "-exp(2G[1])/2)exp(8G[1])Sum((-1/4)n24*(-n)(-4 + 2*(2/3)5(1/3" + "))nexp(ny_1)exp(2nG[1])exp(3nG[2])exp(4nG[3])/(gamma(n + 1)" + "gamma(n + 4)**3), (n, 0, oo)), (G[1], -oo, oo)), (G[2], -oo, oo)), (G[3]" + ", -oo, oo))/5308416") + assert str(marginal_distribution(G, G[0])(y_1)) == marg + omega_f1 = Matrix([[1, h, h]]) + omega_f2 = Matrix([[1, h, h, h], + [h, 1, 2, h], + [h, h, 1, h], + [h, h, h, 1]]) + omega_f3 = Matrix([[6, h, h, h], + [h, 1, 2, h], + [h, h, 1, h], + [h, h, h, 1]]) + v_f = symbols("v_f", positive=False) + l_f = [1, 2, v_f, 4] + m_f = [v_f, 2, 3, 4] + omega_f4 = Matrix([[1, h, h, h, h], + [h, 1, h, h, h], + [h, h, 1, h, h], + [h, h, h, 1, h], + [h, h, h, h, 1]]) + l_f1 = [1, 2, 3, 4, 5] + omega_f5 = Matrix([[1]]) + mu_f5 = l_f5 = [1] + + raises(ValueError, lambda: GMVLGO('G', omega_f1, v, l, mu)) + raises(ValueError, lambda: GMVLGO('G', omega_f2, v, l, mu)) + raises(ValueError, lambda: GMVLGO('G', omega_f3, v, l, mu)) + raises(ValueError, lambda: GMVLGO('G', omega, v_f, l, mu)) + raises(ValueError, lambda: GMVLGO('G', omega, v, l_f, mu)) + raises(ValueError, lambda: GMVLGO('G', omega, v, l, m_f)) + raises(ValueError, lambda: GMVLGO('G', omega_f4, v, l, mu)) + raises(ValueError, lambda: GMVLGO('G', omega, v, l_f1, mu)) + raises(ValueError, lambda: GMVLGO('G', omega_f5, v, l_f5, mu_f5)) + raises(ValueError, lambda: GMVLG('G', Rational(3, 2), v, l, mu)) + def test_MultivariateBeta(): from sympy.stats.joint_rv_types import MultivariateBeta from sympy import gamma		[ { "components": [ { "doc": "", "lines": [ 401, 433 ], "name": "GeneralizedMultivariateLogGammaDistribution", "signature": "class GeneralizedMultivariateLogGammaDistribution(JointDistribution):", "type": "class" }, { "d...	[ "test_sympy__stats__joint_rv_types__GeneralizedMultivariateLogGammaDistribution", "test_GeneralizedMultivariateLogGammaDistribution" ]	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added Generalized Multivariate Log Gamma Distribution <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> Extends https://github.com/sympy/sympy/pull/16576 #### Brief description of what is fixed or changed Generalized Multivariate Log Gamma Distribution has been added. #### Other comments N/A #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * stats * Generalized Multivariate Log Gamma Distribution has been added to `sympy.stats.joint_rv_types` <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/joint_rv_types.py] (definition of GeneralizedMultivariateLogGammaDistribution:) class GeneralizedMultivariateLogGammaDistribution(JointDistribution): (definition of GeneralizedMultivariateLogGammaDistribution.check:) def check(self, delta, v, l, mu): (definition of GeneralizedMultivariateLogGammaDistribution.set:) def set(self): (definition of GeneralizedMultivariateLogGammaDistribution.pdf:) def pdf(self, y): (definition of GeneralizedMultivariateLogGamma:) def GeneralizedMultivariateLogGamma(syms, delta, v, lamda, mu): """Creates a joint random variable with generalized multivariate log gamma distribution. The joint pdf can be found at [1]. Parameters ========== syms: list/tuple/set of symbols for identifying each component delta: A constant in range [0, 1] v: positive real lamda: a list of positive reals mu: a list of positive reals Returns ======= A Random Symbol Examples ======== >>> from sympy.stats import density >>> from sympy.stats.joint_rv import marginal_distribution >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma >>> from sympy import symbols, S >>> v = 1 >>> l, mu = [1, 1, 1], [1, 1, 1] >>> d = S.Half >>> y = symbols('y_1:4', positive=True) >>> Gd = GeneralizedMultivariateLogGamma('G', d, v, l, mu) >>> density(Gd)(y[0], y[1], y[2]) Sum(2(-n)exp((n + 1)(y_1 + y_2 + y_3) - exp(y_1) - exp(y_2) - exp(y_3))/gamma(n + 1)3, (n, 0, oo))/2 References ========== .. [1] https://en.wikipedia.org/wiki/Generalized_multivariate_log-gamma_distribution .. [2] https://www.researchgate.net/publication/234137346_On_a_multivariate_log-gamma_distribution_and_the_use_of_the_distribution_in_the_Bayesian_analysis Note ==== If the GeneralizedMultivariateLogGamma is too long to type use, `from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma as GMVLG` If you want to pass the matrix omega instead of the constant delta, then use, GeneralizedMultivariateLogGammaOmega.""" (definition of GeneralizedMultivariateLogGammaOmega:) def GeneralizedMultivariateLogGammaOmega(syms, omega, v, lamda, mu): """Extends GeneralizedMultivariateLogGamma. Parameters ========== syms: list/tuple/set of symbols for identifying each component omega: A square matrix Every element of square matrix must be absolute value of sqaure root of correlation coefficient v: positive real lamda: a list of positive reals mu: a list of positive reals Returns ======= A Random Symbol Examples ======== >>> from sympy.stats import density >>> from sympy.stats.joint_rv import marginal_distribution >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega >>> from sympy import Matrix, symbols, S >>> omega = Matrix([[1, S.Half, S.Half], [S.Half, 1, S.Half], [S.Half, S.Half, 1]]) >>> v = 1 >>> l, mu = [1, 1, 1], [1, 1, 1] >>> G = GeneralizedMultivariateLogGammaOmega('G', omega, v, l, mu) >>> y = symbols('y_1:4', positive=True) >>> density(G)(y[0], y[1], y[2]) sqrt(2)Sum((1 - sqrt(2)/2)*nexp((n + 1)(y_1 + y_2 + y_3) - exp(y_1) - exp(y_2) - exp(y_3))/gamma(n + 1)*3, (n, 0, oo))/2 References ========== See references of GeneralizedMultivariateLogGamma. Notes ===== If the GeneralizedMultivariateLogGammaOmega is too long to type use, `from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega as GMVLGO`""" [end of new definitions in sympy/stats/joint_rv_types.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-16815	16,815	sympy/sympy	1.5	20234eb7782f1f66c1f1d2a6d05f1179091add0a	2019-05-12T11:50:53Z	diff --git a/sympy/stats/__init__.py b/sympy/stats/__init__.py index ee5889933ebe..12df043bf44b 100644 --- a/sympy/stats/__init__.py +++ b/sympy/stats/__init__.py @@ -50,7 +50,7 @@ from . import frv_types from .frv_types import ( - Bernoulli, Binomial, Coin, Die, DiscreteUniform, FiniteRV, Hypergeometric, + Bernoulli, Binomial, BetaBinomial, Coin, Die, DiscreteUniform, FiniteRV, Hypergeometric, Rademacher, ) __all__.extend(frv_types.__all__) diff --git a/sympy/stats/frv_types.py b/sympy/stats/frv_types.py index 7563868e0fd3..20121985051e 100644 --- a/sympy/stats/frv_types.py +++ b/sympy/stats/frv_types.py @@ -9,6 +9,7 @@ Bernoulli Coin Binomial +BetaBinomial Hypergeometric Rademacher """ @@ -17,6 +18,7 @@ from sympy import (S, sympify, Rational, binomial, cacheit, Integer, Dict, Basic, KroneckerDelta, Dummy, Eq) +from sympy import beta as beta_fn from sympy.concrete.summations import Sum from sympy.core.compatibility import as_int, range from sympy.stats.rv import _value_check @@ -28,6 +30,7 @@ 'Bernoulli', 'Coin', 'Binomial', +'BetaBinomial', 'Hypergeometric', 'Rademacher' ] @@ -305,6 +308,56 @@ def Binomial(name, n, p, succ=1, fail=0): return rv(name, BinomialDistribution, n, p, succ, fail) +#------------------------------------------------------------------------------- +# Beta-binomial distribution ---------------------------------------------------------- + +class BetaBinomialDistribution(SingleFiniteDistribution): + _argnames = ('n', 'alpha', 'beta') + + @staticmethod + def check(n, alpha, beta): + _value_check((n.is_integer, n.is_nonnegative), + "'n' must be nonnegative integer. n = %s." % str(n)) + _value_check((alpha > 0), + "'alpha' must be: alpha > 0 . alpha = %s" % str(alpha)) + _value_check((beta > 0), + "'beta' must be: beta > 0 . beta = %s" % str(beta)) + + @property + @cacheit + def dict(self): + n, a, b = self.n, self.alpha, self.beta + n = as_int(n) + return dict((k, binomial(n, k) * beta_fn(k + a, n - k + b) / beta_fn(a, b)) + for k in range(0, n + 1)) + + +def BetaBinomial(name, n, alpha, beta): + """ + Create a Finite Random Variable representing a Beta-binomial distribution. + + Returns a RandomSymbol. + + Examples + ======== + + >>> from sympy.stats import BetaBinomial, density + >>> from sympy import S + + >>> X = BetaBinomial('X', 2, 1, 1) + >>> density(X).dict + {0: beta(1, 3)/beta(1, 1), 1: 2*beta(2, 2)/beta(1, 1), 2: beta(3, 1)/beta(1, 1)} + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Beta-binomial_distribution + .. [2] http://mathworld.wolfram.com/BetaBinomialDistribution.html + + """ + + return rv(name, BetaBinomialDistribution, n, alpha, beta) + class HypergeometricDistribution(SingleFiniteDistribution): _argnames = ('N', 'm', 'n')	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index b4912d134d17..b78927ac34e1 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1179,6 +1179,10 @@ def test_sympy__stats__frv_types__BinomialDistribution(): from sympy.stats.frv_types import BinomialDistribution assert _test_args(BinomialDistribution(5, S.Half, 1, 0)) +def test_sympy__stats__frv_types__BetaBinomialDistribution(): + from sympy.stats.frv_types import BetaBinomialDistribution + assert _test_args(BetaBinomialDistribution(5, 1, 1)) + def test_sympy__stats__frv_types__HypergeometricDistribution(): from sympy.stats.frv_types import HypergeometricDistribution diff --git a/sympy/stats/tests/test_finite_rv.py b/sympy/stats/tests/test_finite_rv.py index 8c5b37762e06..ea472c398caa 100644 --- a/sympy/stats/tests/test_finite_rv.py +++ b/sympy/stats/tests/test_finite_rv.py @@ -1,9 +1,9 @@ -from sympy import (FiniteSet, S, Symbol, sqrt, nan, +from sympy import (FiniteSet, S, Symbol, sqrt, nan, beta, symbols, simplify, Eq, cos, And, Tuple, Or, Dict, sympify, binomial, cancel, exp, I, Piecewise) from sympy.core.compatibility import range from sympy.matrices import Matrix -from sympy.stats import (DiscreteUniform, Die, Bernoulli, Coin, Binomial, +from sympy.stats import (DiscreteUniform, Die, Bernoulli, Coin, Binomial, BetaBinomial, Hypergeometric, Rademacher, P, E, variance, covariance, skewness, kurtosis, sample, density, where, FiniteRV, pspace, cdf, correlation, moment, cmoment, smoment, characteristic_function, moment_generating_function, @@ -248,6 +248,40 @@ def test_binomial_symbolic(): Y = Binomial('Y', n, p, succ=H, fail=T) assert simplify(E(Y) - (n(Hp + T(1 - p)))) == 0 +def test_beta_binomial(): + # verify parameters + raises(ValueError, lambda: BetaBinomial('b', .2, 1, 2)) + raises(ValueError, lambda: BetaBinomial('b', 2, -1, 2)) + raises(ValueError, lambda: BetaBinomial('b', 2, 1, -2)) + assert BetaBinomial('b', 2, 1, 1) + + # test numeric values + nvals = range(1,5) + alphavals = [S(1)/4, S.Half, S(3)/4, 1, 10] + betavals = [S(1)/4, S.Half, S(3)/4, 1, 10] + + for n in nvals: + for a in alphavals: + for b in betavals: + X = BetaBinomial('X', n, a, b) + assert E(X) == moment(X, 1) + assert variance(X) == cmoment(X, 2) + + # test symbolic + n, a, b = symbols('a b n') + assert BetaBinomial('x', n, a, b) + n = 2 # Because we're using for loops, can't do symbolic n + a, b = symbols('a b', positive=True) + X = BetaBinomial('X', n, a, b) + t = Symbol('t') + + assert E(X).expand() == moment(X, 1).expand() + assert variance(X).expand() == cmoment(X, 2).expand() + assert skewness(X) == smoment(X, 3) + assert characteristic_function(X)(t) == exp(2It)beta(a + 2, b)/beta(a, b) +\ + 2exp(It)beta(a + 1, b + 1)/beta(a, b) + beta(a, b + 2)/beta(a, b) + assert moment_generating_function(X)(t) == exp(2t)beta(a + 2, b)/beta(a, b) +\ + 2exp(t)*beta(a + 1, b + 1)/beta(a, b) + beta(a, b + 2)/beta(a, b) def test_hypergeometric_numeric(): for N in range(1, 5):		[ { "components": [ { "doc": "", "lines": [ 314, 332 ], "name": "BetaBinomialDistribution", "signature": "class BetaBinomialDistribution(SingleFiniteDistribution):", "type": "class" }, { "doc": "", "lines": [ ...	[ "test_sympy__stats__frv_types__BetaBinomialDistribution", "test_discreteuniform", "test_dice", "test_given", "test_domains", "test_dice_bayes", "test_die_args", "test_bernoulli", "test_cdf", "test_coins", "test_binomial_verify_parameters", "test_binomial_numeric", "test_binomial_quantile", ...	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [GSoC] Added Beta-binomial distribution <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed Discrete Univariate Beta-binomial distribution added to `sympy/stats/frv_types.py`. Also added corresponding tests. This distribution will also be useful for Compound distribution module, since it is a binomial distribution with probability `p` being a RV with beta distribution. #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - stats - Added `BetaBinomial` distribution to `sympy.stats.frv_types`. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/frv_types.py] (definition of BetaBinomialDistribution:) class BetaBinomialDistribution(SingleFiniteDistribution): (definition of BetaBinomialDistribution.check:) def check(n, alpha, beta): (definition of BetaBinomialDistribution.dict:) def dict(self): (definition of BetaBinomial:) def BetaBinomial(name, n, alpha, beta): """Create a Finite Random Variable representing a Beta-binomial distribution. Returns a RandomSymbol. Examples ======== >>> from sympy.stats import BetaBinomial, density >>> from sympy import S >>> X = BetaBinomial('X', 2, 1, 1) >>> density(X).dict {0: beta(1, 3)/beta(1, 1), 1: 2*beta(2, 2)/beta(1, 1), 2: beta(3, 1)/beta(1, 1)} References ========== .. [1] https://en.wikipedia.org/wiki/Beta-binomial_distribution .. [2] http://mathworld.wolfram.com/BetaBinomialDistribution.html""" [end of new definitions in sympy/stats/frv_types.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-16814	16,814	sympy/sympy	1.5	19341137da6e3ae8fc59784f5d044412539d05e9	2019-05-12T08:57:13Z	diff --git a/sympy/stats/__init__.py b/sympy/stats/__init__.py index db7d4832713c..c38255f01257 100644 --- a/sympy/stats/__init__.py +++ b/sympy/stats/__init__.py @@ -61,9 +61,9 @@ Arcsin, Benini, Beta, BetaNoncentral, BetaPrime, Cauchy, Chi, ChiNoncentral, ChiSquared, Dagum, Erlang, Exponential, FDistribution, FisherZ, Frechet, Gamma, GammaInverse, Gumbel, Gompertz, Kumaraswamy, Laplace, Logistic, LogNormal, - Maxwell, Nakagami, Normal, Pareto, QuadraticU, RaisedCosine, Rayleigh, + Maxwell, Nakagami, Normal, GaussianInverse, Pareto, QuadraticU, RaisedCosine, Rayleigh, ShiftedGompertz, StudentT, Trapezoidal, Triangular, Uniform, UniformSum, VonMises, - Weibull, WignerSemicircle + Weibull, WignerSemicircle, Wald ) __all__.extend(crv_types.__all__) diff --git a/sympy/stats/crv_types.py b/sympy/stats/crv_types.py index 063a541742ac..047960bbd4e5 100644 --- a/sympy/stats/crv_types.py +++ b/sympy/stats/crv_types.py @@ -91,6 +91,7 @@ 'Maxwell', 'Nakagami', 'Normal', +'GaussianInverse', 'Pareto', 'QuadraticU', 'RaisedCosine', @@ -1492,7 +1493,7 @@ def sample(self): from scipy.stats import invgamma return invgamma.rvs(float(self.a), 0, float(self.b)) else: - raise NotImplementedError('Sampling the inverse Gamma Distribution requires Scipy.') + raise NotImplementedError('Sampling the Inverse Gamma Distribution requires Scipy.') def _characteristic_function(self, t): a, b = self.a, self.b @@ -2304,7 +2305,7 @@ def Normal(name, mean, std): >>> m = Normal('X', [1, 2], [[2, 1], [1, 2]]) >>> from sympy.stats.joint_rv import marginal_distribution - >>> pprint(density(m)(y, z)) + >>> pprint(density(m)(y, z), use_unicode=False) /1 y\ /2y z\ / z\ / y 2z \ \|- - -\|\|--- - -\| + \|1 - -\|\|- - + --- - 1\| ___ \2 2/ \ 3 3/ \ 2/ \ 3 3 / @@ -2331,6 +2332,120 @@ def Normal(name, mean, std): MultivariateNormalDistribution, name, mean, std) return rv(name, NormalDistribution, (mean, std)) + +#------------------------------------------------------------------------------- +# Inverse Gaussian distribution ---------------------------------------------------------- + + +class GaussianInverseDistribution(SingleContinuousDistribution): + _argnames = ('mean', 'shape') + + @property + def set(self): + return Interval(0, oo) + + @staticmethod + def check(mean, shape): + _value_check(shape > 0, "Shape parameter must be positive") + _value_check(mean > 0, "Mean must be positive") + + def pdf(self, x): + mu, s = self.mean, self.shape + return exp(-s(x - mu)2 / (2xmu2)) sqrt(s/((2pix*3))) + + def sample(self): + scipy = import_module('scipy') + if scipy: + from scipy.stats import invgauss + return invgauss.rvs(float(self.mean/self.shape), 0, float(self.shape)) + else: + raise NotImplementedError( + 'Sampling the Inverse Gaussian Distribution requires Scipy.') + + def _cdf(self, x): + from sympy.stats import cdf + mu, s = self.mean, self.shape + stdNormalcdf = cdf(Normal('x', 0, 1)) + + first_term = stdNormalcdf(sqrt(s/x) ((x/mu) - S.One)) + second_term = exp(2s/mu) stdNormalcdf(-sqrt(s/x)(x/mu + S.One)) + + return first_term + second_term + + def _characteristic_function(self, t): + mu, s = self.mean, self.shape + return exp((s/mu)(1 - sqrt(1 - (2mu2It)/s))) + + def _moment_generating_function(self, t): + mu, s = self.mean, self.shape + return exp((s/mu)(1 - sqrt(1 - (2mu2t)/s))) + + +def GaussianInverse(name, mean, shape): + r""" + Create a continuous random variable with an Inverse Gaussian distribution. + Inverse Gaussian distribution is also known as Wald distribution. + + The density of the Inverse Gaussian distribution is given by + + .. math:: + f(x) := \sqrt{\frac{\lambda}{2\pi x^3}} e^{-\frac{\lambda(x-\mu)^2}{2x\mu^2}} + + Parameters + ========== + + mu : Positive number representing the mean + lambda : Positive number representing the shape parameter + + Returns + ======= + + A RandomSymbol. + + Examples + ======== + + >>> from sympy.stats import GaussianInverse, density, cdf, E, std, skewness + >>> from sympy import Symbol, pprint + + >>> mu = Symbol("mu", positive=True) + >>> lamda = Symbol("lambda", positive=True) + >>> z = Symbol("z", positive=True) + >>> X = GaussianInverse("x", mu, lamda) + + >>> D = density(X)(z) + >>> pprint(D, use_unicode=False) + 2 + -lambda(-mu + z) + ------------------- + 2 + ___ ________ 2mu z + \/ 2 \/ lambda e + ------------------------------------- + ____ 3/2 + 2\/ pi z + + >>> E(X) + mu + + >>> std(X).expand() + mu(3/2)/sqrt(lambda) + + >>> skewness(X).expand() + 3sqrt(mu)/sqrt(lambda) + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Inverse_Gaussian_distribution + .. [2] http://mathworld.wolfram.com/InverseGaussianDistribution.html + + """ + + return rv(name, GaussianInverseDistribution, (mean, shape)) + +Wald = GaussianInverse + #------------------------------------------------------------------------------- # Pareto distribution ----------------------------------------------------------	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 32566f4c34f9..802fca1881d9 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1387,6 +1387,10 @@ def test_sympy__stats__crv_types__NormalDistribution(): from sympy.stats.crv_types import NormalDistribution assert _test_args(NormalDistribution(0, 1)) +def test_sympy__stats__crv_types__GaussianInverseDistribution(): + from sympy.stats.crv_types import GaussianInverseDistribution + assert _test_args(GaussianInverseDistribution(1, 1)) + def test_sympy__stats__crv_types__ParetoDistribution(): from sympy.stats.crv_types import ParetoDistribution diff --git a/sympy/stats/tests/test_continuous_rv.py b/sympy/stats/tests/test_continuous_rv.py index c39eb9fe35ec..092d3966ee55 100644 --- a/sympy/stats/tests/test_continuous_rv.py +++ b/sympy/stats/tests/test_continuous_rv.py @@ -16,10 +16,10 @@ ChiNoncentral, Dagum, Erlang, Exponential, FDistribution, FisherZ, Frechet, Gamma, GammaInverse, Gompertz, Gumbel, Kumaraswamy, Laplace, Logistic, - LogNormal, Maxwell, Nakagami, Normal, Pareto, + LogNormal, Maxwell, Nakagami, Normal, GaussianInverse, Pareto, QuadraticU, RaisedCosine, Rayleigh, ShiftedGompertz, StudentT, Trapezoidal, Triangular, Uniform, UniformSum, - VonMises, Weibull, WignerSemicircle, correlation, + VonMises, Weibull, WignerSemicircle, Wald, correlation, moment, cmoment, smoment, quantile) from sympy.stats.crv_types import NormalDistribution from sympy.stats.joint_rv import JointPSpace @@ -158,6 +158,12 @@ def test_characteristic_function(): assert cf(0) == 1 assert cf(1).expand() == S(25)/26 + 5I/26 + X = GaussianInverse('x', 1, 1) + cf = characteristic_function(X) + assert cf(0) == 1 + assert cf(1) == exp(1 - sqrt(1 - 2I)) + + def test_moment_generating_function(): t = symbols('t', positive=True) @@ -710,6 +716,40 @@ def test_nakagami(): (lowergamma(mu, mux2/omega)/gamma(mu), x > 0), (0, True)) +def test_gaussian_inverse(): + # test for symbolic parameters + a, b = symbols('a b') + assert GaussianInverse('x', a, b) + + # Inverse Gaussian distribution is also known as Wald distribution + # `GaussianInverse` can also be referred by the name `Wald` + a, b, z = symbols('a b z') + X = Wald('x', a, b) + assert density(X)(z) == sqrt(2)sqrt(b/z*3)exp(-b(-a + z)2/(2a*2z))/(2sqrt(pi)) + + a, b = symbols('a b', positive=True) + z = Symbol('z', positive=True) + + X = GaussianInverse('x', a, b) + assert density(X)(z) == sqrt(2)sqrt(b)sqrt(z(-3))exp(-b(-a + z)2/(2a*2z))/(2sqrt(pi)) + assert E(X) == a + assert variance(X).expand() == a3/b + assert cdf(X)(z) == (S.Half - erf(sqrt(2)sqrt(b)(1 + z/a)/(2sqrt(z)))/2)exp(2b/a) +\ + erf(sqrt(2)sqrt(b)(-1 + z/a)/(2*sqrt(z)))/2 + S.Half + + a = symbols('a', nonpositive=True) + raises(ValueError, lambda: GaussianInverse('x', a, b)) + + a = symbols('a', positive=True) + b = symbols('b', nonpositive=True) + raises(ValueError, lambda: GaussianInverse('x', a, b)) + +def test_sampling_gaussian_inverse(): + scipy = import_module('scipy') + if not scipy: + skip('Scipy not installed. Abort tests for sampling of Gaussian inverse.') + X = GaussianInverse("x", 1, 1) + assert sample(X) in X.pspace.domain.set def test_pareto(): xm, beta = symbols('xm beta', positive=True)		[ { "components": [ { "doc": "", "lines": [ 2340, 2381 ], "name": "GaussianInverseDistribution", "signature": "class GaussianInverseDistribution(SingleContinuousDistribution):", "type": "class" }, { "doc": "", "l...	[ "test_sympy__stats__crv_types__GaussianInverseDistribution", "test_single_normal", "test_conditional_1d", "test_ContinuousDomain", "test_symbolic", "test_cdf", "test_characteristic_function", "test_moment_generating_function", "test_sample_continuous", "test_ContinuousRV", "test_arcsin", "test...	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [GSoC] Added Inverse Normal distribution <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed Univariate Inverse Normal distribution has been added to sympy/stats/crv_types. Corresponding tests have to be added. #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - stats - Addition of Inverse Normal distribution to `sympy/stats/crv_types.py` <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/crv_types.py] (definition of GaussianInverseDistribution:) class GaussianInverseDistribution(SingleContinuousDistribution): (definition of GaussianInverseDistribution.set:) def set(self): (definition of GaussianInverseDistribution.check:) def check(mean, shape): (definition of GaussianInverseDistribution.pdf:) def pdf(self, x): (definition of GaussianInverseDistribution.sample:) def sample(self): (definition of GaussianInverseDistribution._cdf:) def _cdf(self, x): (definition of GaussianInverseDistribution._characteristic_function:) def _characteristic_function(self, t): (definition of GaussianInverseDistribution._moment_generating_function:) def _moment_generating_function(self, t): (definition of GaussianInverse:) def GaussianInverse(name, mean, shape): """Create a continuous random variable with an Inverse Gaussian distribution. Inverse Gaussian distribution is also known as Wald distribution. The density of the Inverse Gaussian distribution is given by .. math:: f(x) := \sqrt{\frac{\lambda}{2\pi x^3}} e^{-\frac{\lambda(x-\mu)^2}{2x\mu^2}} Parameters ========== mu : Positive number representing the mean lambda : Positive number representing the shape parameter Returns ======= A RandomSymbol. Examples ======== >>> from sympy.stats import GaussianInverse, density, cdf, E, std, skewness >>> from sympy import Symbol, pprint >>> mu = Symbol("mu", positive=True) >>> lamda = Symbol("lambda", positive=True) >>> z = Symbol("z", positive=True) >>> X = GaussianInverse("x", mu, lamda) >>> D = density(X)(z) >>> pprint(D, use_unicode=False) 2 -lambda(-mu + z) ------------------- 2 ___ ________ 2mu z \/ 2 \/ lambda e ------------------------------------- ____ 3/2 2\/ pi z >>> E(X) mu >>> std(X).expand() mu(3/2)/sqrt(lambda) >>> skewness(X).expand() 3sqrt(mu)/sqrt(lambda) References ========== .. [1] https://en.wikipedia.org/wiki/Inverse_Gaussian_distribution .. [2] http://mathworld.wolfram.com/InverseGaussianDistribution.html""" [end of new definitions in sympy/stats/crv_types.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-16808	16,808	sympy/sympy	1.5	0b090278fd9bd2f9f6f02268b0d0ccf968a9db7b	2019-05-11T10:53:55Z	diff --git a/sympy/stats/joint_rv.py b/sympy/stats/joint_rv.py index 30cddf1e2ced..9a34cd4054b8 100644 --- a/sympy/stats/joint_rv.py +++ b/sympy/stats/joint_rv.py @@ -101,6 +101,7 @@ def marginal_distribution(self, indices): if self.distribution.is_Continuous: f = Lambda(sym, integrate(self.distribution(all_syms), limits)) elif self.distribution.is_Discrete: + limits = [(limit[0], limit[1].inf, limit[1].sup) for limit in limits] f = Lambda(sym, summation(self.distribution(all_syms), limits)) return f.xreplace(replace_dict) diff --git a/sympy/stats/joint_rv_types.py b/sympy/stats/joint_rv_types.py index b973729593e1..5f3ecbdc9894 100644 --- a/sympy/stats/joint_rv_types.py +++ b/sympy/stats/joint_rv_types.py @@ -1,5 +1,5 @@ from sympy import (sympify, S, pi, sqrt, exp, Lambda, Indexed, Gt, - IndexedBase) + IndexedBase, besselk, gamma, Interval, Range, factorial, Mul, Integer) from sympy.matrices import ImmutableMatrix from sympy.matrices.expressions.determinant import det from sympy.stats.joint_rv import (JointDistribution, JointPSpace, @@ -124,7 +124,6 @@ def check(self, mu, sigma): "The covariance matrix must be positive definite. ") def pdf(self, args): - from sympy.functions.special.bessel import besselk mu, sigma = self.mu, self.sigma mu_T = mu.transpose() k = S(len(mu)) @@ -159,7 +158,6 @@ def check(self, mu, sigma, v): "The shape matrix must be positive definite. ") def pdf(self, args): - from sympy.functions.special.gamma_functions import gamma mu, sigma = self.mu, self.shape_mat v = S(self.dof) k = S(len(mu)) @@ -205,11 +203,9 @@ def check(self, mu, lamda, alpha, beta): @property def set(self): - from sympy.sets.sets import Interval return S.RealsInterval(0, S.Infinity) def pdf(self, x, tau): - from sympy.functions.special.gamma_functions import gamma beta, alpha, lamda = self.beta, self.alpha, self.lamda mu = self.mu @@ -218,7 +214,6 @@ def pdf(self, x, tau): exp(-1(lamdatau(x - mu)2)/S(2)) def marginal_distribution(self, indices, sym): - from sympy.functions.special.gamma_functions import gamma if len(indices) == 2: return self.pdf(sym) if indices[0] == 0: @@ -253,3 +248,138 @@ def NormalGamma(syms, mu, lamda, alpha, beta): A random symbol """ return multivariate_rv(NormalGammaDistribution, syms, mu, lamda, alpha, beta) + +#------------------------------------------------------------------------------- +# Multinomial distribution --------------------------------------------------------- + +class MultinomialDistribution(JointDistribution): + + _argnames = ['n', 'p'] + is_Continuous=False + is_Discrete = True + + def check(self, n, p): + _value_check(((n > 0) != False) and isinstance(n, Integer), + "number of trials must be a positve integer") + for p_k in p: + _value_check((p_k >= 0) != False, + "probability must be at least a positive symbol.") + + @property + def set(self): + return Range(0, self.n)len(self.p) + + def pdf(self, x): + n, p = self.n, self.p + term_1 = factorial(n)/Mul.fromiter([factorial(x_k) for x_k in x]) + term_2 = Mul.fromiter([p_k*x_k for p_k, x_k in zip(p, x)]) + return term_1term_2 + +def Multinomial(syms, n, p): + """ + Creates a discrete random variable with Multinomial Distribution. + + The density of the said distribution can be found at [1]. + + Parameters + ========== + n: postive integer of class Integer, + number of trials + p: event probabilites, >= 0 and <= 1 + + Returns + ======= + A RandomSymbol. + + Examples + ======== + >>> from sympy.stats import density + >>> from sympy.stats.joint_rv import marginal_distribution + >>> from sympy.stats.joint_rv_types import Multinomial + >>> from sympy import Symbol + >>> from sympy import symbols + >>> x1, x2, x3 = symbols('x1, x2, x3', nonnegative=True, integer=True) + >>> p1, p2, p3 = symbols('p1, p2, p3', positive=True) + >>> M = Multinomial('M', 3, p1, p2, p3) + >>> density(M)(x1, x2, x3) + 6p1*x1p2*x2p3*x3/(factorial(x1)factorial(x2)factorial(x3)) + >>> marginal_distribution(M, M[0])(x1).subs(x1, 1) + 3p1p22p3*2/2 + 3p1p22p3 + 3p1p2*2 + 3p1p2p3*2 + + 6p1p2p3 + 6p1p2 + 3p1p3*2 + 6p1p3 + 6p1 + + References + ========== + .. [1] https://en.wikipedia.org/wiki/Multinomial_distribution + .. [2] http://mathworld.wolfram.com/MultinomialDistribution.html + """ + if not isinstance(p[0], list): + p = (list(p), ) + return multivariate_rv(MultinomialDistribution, syms, n, p[0]) + +#------------------------------------------------------------------------------- +# Negative Multinomial Distribution --------------------------------------------------------- + +class NegativeMultinomialDistribution(JointDistribution): + + _argnames = ['k0', 'p'] + is_Continuous=False + is_Discrete = True + + def check(self, k0, p): + _value_check(((k0 > 0) != False) and isinstance(k0, Integer), + "number of failures must be a positve integer") + for p_k in p: + _value_check((p_k >= 0) != False, + "probability must be at least a positive symbol.") + + @property + def set(self): + return S.Naturals0*len(self.p) + + def pdf(self, k): + k0, p = self.k0, self.p + term_1 = (gamma(k0 + sum(k))(1 - sum(p))k0)/gamma(k0) + term_2 = Mul.fromiter([piki/factorial(ki) for pi, ki in zip(p, k)]) + return term_1term_2 + +def NegativeMultinomial(syms, k0, p): + """ + Creates a discrete random variable with Negative Multinomial Distribution. + + The density of the said distribution can be found at [1]. + + Parameters + ========== + k0: postive integer of class Integer, + number of failures before the experiment is stopped + p: event probabilites, >= 0 and <= 1 + + Returns + ======= + A RandomSymbol. + + Examples + ======== + >>> from sympy.stats import density + >>> from sympy.stats.joint_rv import marginal_distribution + >>> from sympy.stats.joint_rv_types import NegativeMultinomial + >>> from sympy import symbols + >>> x1, x2, x3 = symbols('x1, x2, x3', nonnegative=True, integer=True) + >>> p1, p2, p3 = symbols('p1, p2, p3', positive=True) + >>> N = NegativeMultinomial('M', 3, p1, p2, p3) + >>> N_c = NegativeMultinomial('M', 3, 0.1, 0.1, 0.1) + >>> density(N)(x1, x2, x3) + p1x1p2*x2p3*x3(-p1 - p2 - p3 + 1)*3gamma(x1 + x2 + + x3 + 3)/(2factorial(x1)factorial(x2)*factorial(x3)) + >>> marginal_distribution(N_c, N_c[0])(1).evalf().round(2) + 0.25 + + + References + ========== + .. [1] https://en.wikipedia.org/wiki/Negative_multinomial_distribution + .. [2] http://mathworld.wolfram.com/NegativeBinomialDistribution.html + """ + if not isinstance(p[0], list): + p = (list(p), ) + return multivariate_rv(NegativeMultinomialDistribution, syms, k0, p[0])	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 7d8ea35b66cf..b86a8d3dd501 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1496,6 +1496,13 @@ def test_sympy__stats__joint_rv_types__NormalGammaDistribution(): from sympy.stats.joint_rv_types import NormalGammaDistribution assert _test_args(NormalGammaDistribution(1, 2, 3, 4)) +def test_sympy__stats__joint_rv_types__MultinomialDistribution(): + from sympy.stats.joint_rv_types import MultinomialDistribution + assert _test_args(MultinomialDistribution(5, [0.5, 0.1, 0.3])) + +def test_sympy__stats__joint_rv_types__NegativeMultinomialDistribution(): + from sympy.stats.joint_rv_types import NegativeMultinomialDistribution + assert _test_args(NegativeMultinomialDistribution(5, [0.5, 0.1, 0.3])) def test_sympy__core__symbol__Dummy(): from sympy.core.symbol import Dummy diff --git a/sympy/stats/tests/test_joint_rv.py b/sympy/stats/tests/test_joint_rv.py index ddb159a5f321..a9ae6e2c7b4b 100644 --- a/sympy/stats/tests/test_joint_rv.py +++ b/sympy/stats/tests/test_joint_rv.py @@ -1,4 +1,5 @@ -from sympy import symbols, pi, oo, S, exp, sqrt, besselk, Indexed +from sympy import (symbols, pi, oo, S, exp, sqrt, besselk, Indexed, factorial, + simplify, gamma) from sympy.stats import density from sympy.stats.joint_rv import marginal_distribution from sympy.stats.joint_rv_types import JointRV @@ -53,6 +54,36 @@ def test_NormalGamma(): 3sqrt(10)gamma(S(7)/4)/(10sqrt(pi)gamma(S(5)/4)) assert marginal_distribution(ng, y)(1) == exp(-S(1)/4)/128 +def test_Multinomial(): + from sympy.stats.joint_rv_types import Multinomial + n, x1, x2, x3, x4 = symbols('n, x1, x2, x3, x4', nonnegative=True, integer=True) + p1, p2, p3, p4 = symbols('p1, p2, p3, p4', positive=True) + p1_f = symbols('p1_f', negative=True) + M = Multinomial('M', 3, [p1, p2, p3, p4]) + M_c = Multinomial('C', 3, 0.5, 0.4, 0.3, 0.2) + f = factorial + assert simplify(density(M)(x1, x2, x3, x4) - + S(6)p1x1p2*x2p3*x3p4*x4/(f(x1)f(x2)f(x3)f(x4))) == S(0) + assert marginal_distribution(M_c, M_c[0])(1).round(2) == 7.29 + raises(ValueError, lambda: Multinomial('b1', 5, [p1, p2, p3, p1_f])) + raises(ValueError, lambda: Multinomial('b2', n, [p1, p2, p3, p4])) + +def test_NegativeMultinomial(): + from sympy.stats.joint_rv_types import NegativeMultinomial + k0, x1, x2, x3, x4 = symbols('k0, x1, x2, x3, x4', nonnegative=True, integer=True) + p1, p2, p3, p4 = symbols('p1, p2, p3, p4', positive=True) + p1_f = symbols('p1_f', negative=True) + N = NegativeMultinomial('N', 4, [p1, p2, p3, p4]) + N_c = NegativeMultinomial('C', 4, 0.1, 0.2, 0.3) + g = gamma + f = factorial + assert simplify(density(N)(x1, x2, x3, x4) - + p1*x1p2*x2p3*x3p4*x4(-p1 - p2 - p3 - p4 + 1)*4g(x1 + x2 + + x3 + x4 + 4)/(6f(x1)f(x2)f(x3)f(x4))) == S(0) + assert marginal_distribution(N_c, N_c[0])(1).evalf().round(2) == 0.33 + raises(ValueError, lambda: NegativeMultinomial('b1', 5, [p1, p2, p3, p1_f])) + raises(ValueError, lambda: NegativeMultinomial('b2', k0, [p1, p2, p3, p4])) + def test_JointPSpace_margial_distribution(): from sympy.stats.joint_rv_types import MultivariateT from sympy import polar_lift		[ { "components": [ { "doc": "", "lines": [ 255, 276 ], "name": "MultinomialDistribution", "signature": "class MultinomialDistribution(JointDistribution):", "type": "class" }, { "doc": "", "lines": [ 26...	[ "test_sympy__stats__joint_rv_types__MultinomialDistribution", "test_sympy__stats__joint_rv_types__NegativeMultinomialDistribution", "test_Multinomial", "test_NegativeMultinomial" ]	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added Multinomial, NegativeMultinomial Distribution <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> Extends https://github.com/sympy/sympy/pull/16576/ Don't close any of the two PRs. #### Brief description of what is fixed or changed Multinomial Distribution has been added to sympy.stats.joint_rv_types. There are import issues remaining to be resolved. #### Other comments N/A #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * stats * Addition of Multinomial Distribution to `sympy.stats.joint_rv_types` <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/joint_rv_types.py] (definition of MultinomialDistribution:) class MultinomialDistribution(JointDistribution): (definition of MultinomialDistribution.check:) def check(self, n, p): (definition of MultinomialDistribution.set:) def set(self): (definition of MultinomialDistribution.pdf:) def pdf(self, x): (definition of Multinomial:) def Multinomial(syms, n, p): """Creates a discrete random variable with Multinomial Distribution. The density of the said distribution can be found at [1]. Parameters ========== n: postive integer of class Integer, number of trials p: event probabilites, >= 0 and <= 1 Returns ======= A RandomSymbol. Examples ======== >>> from sympy.stats import density >>> from sympy.stats.joint_rv import marginal_distribution >>> from sympy.stats.joint_rv_types import Multinomial >>> from sympy import Symbol >>> from sympy import symbols >>> x1, x2, x3 = symbols('x1, x2, x3', nonnegative=True, integer=True) >>> p1, p2, p3 = symbols('p1, p2, p3', positive=True) >>> M = Multinomial('M', 3, p1, p2, p3) >>> density(M)(x1, x2, x3) 6p1x1p2*x2p3*x3/(factorial(x1)factorial(x2)factorial(x3)) >>> marginal_distribution(M, M[0])(x1).subs(x1, 1) 3p1p22p3*2/2 + 3p1p22p3 + 3p1p2*2 + 3p1p2p3*2 + 6p1p2p3 + 6p1p2 + 3p1p3*2 + 6p1p3 + 6p1 References ========== .. [1] https://en.wikipedia.org/wiki/Multinomial_distribution .. [2] http://mathworld.wolfram.com/MultinomialDistribution.html""" (definition of NegativeMultinomialDistribution:) class NegativeMultinomialDistribution(JointDistribution): (definition of NegativeMultinomialDistribution.check:) def check(self, k0, p): (definition of NegativeMultinomialDistribution.set:) def set(self): (definition of NegativeMultinomialDistribution.pdf:) def pdf(self, k): (definition of NegativeMultinomial:) def NegativeMultinomial(syms, k0, p): """Creates a discrete random variable with Negative Multinomial Distribution. The density of the said distribution can be found at [1]. Parameters ========== k0: postive integer of class Integer, number of failures before the experiment is stopped p: event probabilites, >= 0 and <= 1 Returns ======= A RandomSymbol. Examples ======== >>> from sympy.stats import density >>> from sympy.stats.joint_rv import marginal_distribution >>> from sympy.stats.joint_rv_types import NegativeMultinomial >>> from sympy import symbols >>> x1, x2, x3 = symbols('x1, x2, x3', nonnegative=True, integer=True) >>> p1, p2, p3 = symbols('p1, p2, p3', positive=True) >>> N = NegativeMultinomial('M', 3, p1, p2, p3) >>> N_c = NegativeMultinomial('M', 3, 0.1, 0.1, 0.1) >>> density(N)(x1, x2, x3) p1*x1p2*x2p3*x3(-p1 - p2 - p3 + 1)*3gamma(x1 + x2 + x3 + 3)/(2factorial(x1)factorial(x2)*factorial(x3)) >>> marginal_distribution(N_c, N_c[0])(1).evalf().round(2) 0.25 References ========== .. [1] https://en.wikipedia.org/wiki/Negative_multinomial_distribution .. [2] http://mathworld.wolfram.com/NegativeBinomialDistribution.html""" [end of new definitions in sympy/stats/joint_rv_types.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
joke2k__faker-954	954	joke2k/faker	null	6a26cd10b24e73f1efb2c53033b294a31f831417	2019-05-10T17:57:22Z	diff --git a/faker/providers/automotive/pl_PL/__init__.py b/faker/providers/automotive/pl_PL/__init__.py new file mode 100644 index 0000000000..965a996b9f --- /dev/null +++ b/faker/providers/automotive/pl_PL/__init__.py @@ -0,0 +1,28 @@ +# coding=utf-8 + +from __future__ import unicode_literals +from .. import Provider as AutomotiveProvider + + +class Provider(AutomotiveProvider): + # from + # https://en.wikipedia.org/wiki/Vehicle_registration_plates_of_Poland + license_formats = ( + '?? #####', + '?? ####?', + '?? ###??', + '?? #?###', + '?? #??##', + '??? ?###', + '??? ##??', + '??? #?##', + '??? ##?#', + '??? #??#', + '??? ??##', + '??? #####', + '??? ####?', + '??? ###??', + ) + + def license_plate_regex_formats(self): + return [plate.replace('?', '[A-Z]').replace('#', '[0-9]') for plate in self.license_formats] diff --git a/faker/providers/person/pl_PL/__init__.py b/faker/providers/person/pl_PL/__init__.py index 11c17670b9..49c622df8a 100644 --- a/faker/providers/person/pl_PL/__init__.py +++ b/faker/providers/person/pl_PL/__init__.py @@ -21,6 +21,28 @@ def checksum_identity_card_number(characters): return check_digit +def generate_pesel_checksum_value(pesel_digits): + """ + Calculates and returns a control digit for given PESEL. + """ + checksum_values = [9, 7, 3, 1, 9, 7, 3, 1, 9, 7] + + checksum = sum((int(a) * b for a, b in zip(list(pesel_digits), checksum_values))) + + return checksum % 10 + + +def checksum_pesel_number(pesel_digits): + """ + Calculates and returns True if PESEL is valid. + """ + checksum_values = [1, 3, 7, 9, 1, 3, 7, 9, 1, 3, 1] + + checksum = sum((int(a) * b for a, b in zip(list(pesel_digits), checksum_values))) + + return checksum % 10 == 0 + + class Provider(PersonProvider): formats = ( '{{first_name}} {{last_name}}', @@ -702,3 +724,31 @@ def identity_card_number(self): identity[3] = checksum_identity_card_number(identity) return ''.join(str(character) for character in identity) + + def pesel(self): + """ + Returns 11 characters of Universal Electronic System for Registration of the Population. + Polish: Powszechny Elektroniczny System Ewidencji Ludności. + + PESEL has 11 digits which identifies just one person. + Month: if person was born in 1900-2000, december is 12. If person was born > 2000, we have to add 20 to month, + so december is 32. + Person id: last digit identifies person's sex. Even for females, odd for males. + + https://en.wikipedia.org/wiki/PESEL + """ + + birth = self.generator.date_of_birth() + + year_pesel = str(birth.year)[-2:] + month_pesel = birth.month if birth.year < 2000 else birth.month + 20 + day_pesel = birth.day + person_id = self.random_int(1000, 9999) + + current_pesel = '{year}{month:02d}{day:02d}{person_id:04d}'.format(year=year_pesel, month=month_pesel, + day=day_pesel, + person_id=person_id) + + checksum_value = generate_pesel_checksum_value(current_pesel) + return '{pesel_without_checksum}{checksum_value}'.format(pesel_without_checksum=current_pesel, + checksum_value=checksum_value)	diff --git a/tests/providers/test_automotive.py b/tests/providers/test_automotive.py index 88c57c5cd0..20f3c39ec8 100644 --- a/tests/providers/test_automotive.py +++ b/tests/providers/test_automotive.py @@ -49,3 +49,15 @@ def setUp(self): def test_sv_SE_plate_format(self): plate = self.factory.license_plate() assert re.match(r"[A-Z]{3} \d{2}[\dA-Z]{1}", plate), "%s is not in the correct format." % plate + + +class TestPlPL(unittest.TestCase): + + def setUp(self): + self.factory = Faker('pl_PL') + + def test_pl_PL_plate_format(self): + plate = self.factory.license_plate() + patterns = self.factory.license_plate_regex_formats() + assert re.match(r'{patterns}'.format(patterns='\|'.join(patterns)), + plate), '{plate} is not the correct format.'.format(plate=plate) diff --git a/tests/providers/test_person.py b/tests/providers/test_person.py index e7920b242a..c5ec3f8080 100644 --- a/tests/providers/test_person.py +++ b/tests/providers/test_person.py @@ -15,6 +15,7 @@ from faker.providers.person.cs_CZ import Provider as CsCZProvider from faker.providers.person.pl_PL import ( checksum_identity_card_number as pl_checksum_identity_card_number, + checksum_pesel_number as pl_checksum_pesel_number, ) from faker.providers.person.zh_CN import Provider as ZhCNProvider from faker.providers.person.zh_TW import Provider as ZhTWProvider @@ -205,6 +206,14 @@ def test_identity_card_number(self): for _ in range(100): assert re.search(r'^[A-Z]{3}\d{6}$', self.factory.identity_card_number()) + def test_pesel_number_checksum(self): + assert pl_checksum_pesel_number('31090655159') is True + assert pl_checksum_pesel_number('95030853577') is True + assert pl_checksum_pesel_number('05260953442') is True + assert pl_checksum_pesel_number('31090655158') is False + assert pl_checksum_pesel_number('95030853576') is False + assert pl_checksum_pesel_number('05260953441') is False + class TestCsCZ(unittest.TestCase):		[ { "components": [ { "doc": "", "lines": [ 7, 28 ], "name": "Provider", "signature": "class Provider(AutomotiveProvider):", "type": "class" }, { "doc": "", "lines": [ 27, 28 ], ...	[ "tests/providers/test_automotive.py::TestPtBR::test_plate_has_been_generated", "tests/providers/test_automotive.py::TestHuHU::test_hu_HU_plate_format", "tests/providers/test_automotive.py::TestDeDe::test_de_DE_plate_format", "tests/providers/test_automotive.py::TestSvSE::test_sv_SE_plate_format", "tests/pro...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Pldevelop ### What does this changes PESEL and automotive plates for Poland with tests. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/automotive/pl_PL/__init__.py] (definition of Provider:) class Provider(AutomotiveProvider): (definition of Provider.license_plate_regex_formats:) def license_plate_regex_formats(self): [end of new definitions in faker/providers/automotive/pl_PL/__init__.py] [start of new definitions in faker/providers/person/pl_PL/__init__.py] (definition of generate_pesel_checksum_value:) def generate_pesel_checksum_value(pesel_digits): """Calculates and returns a control digit for given PESEL.""" (definition of checksum_pesel_number:) def checksum_pesel_number(pesel_digits): """Calculates and returns True if PESEL is valid.""" (definition of Provider.pesel:) def pesel(self): """Returns 11 characters of Universal Electronic System for Registration of the Population. Polish: Powszechny Elektroniczny System Ewidencji Ludności. PESEL has 11 digits which identifies just one person. Month: if person was born in 1900-2000, december is 12. If person was born > 2000, we have to add 20 to month, so december is 32. Person id: last digit identifies person's sex. Even for females, odd for males. https://en.wikipedia.org/wiki/PESEL""" [end of new definitions in faker/providers/person/pl_PL/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		6edfdbf6ae90b0153309e3bf066aa3b2d16494a7
falconry__falcon-1537	1,537	falconry/falcon	null	e46ca1c1695fb43fedd300c1a771bfff8bf5c34e	2019-05-07T20:14:07Z	diff --git a/docs/_newsfragments/urlencoded-form-media-handler.feature.rst b/docs/_newsfragments/urlencoded-form-media-handler.feature.rst new file mode 100644 index 000000000..9350c3745 --- /dev/null +++ b/docs/_newsfragments/urlencoded-form-media-handler.feature.rst @@ -0,0 +1,2 @@ +``URLEncodedFormHandler`` was added for handling URL-encoded forms (of content +type ``application/x-www-form-urlencoded``) as ``Request.media``. diff --git a/docs/api/media.rst b/docs/api/media.rst index 90c7d3e27..06ec16618 100644 --- a/docs/api/media.rst +++ b/docs/api/media.rst @@ -67,6 +67,7 @@ middleware. Here is an example of how this can be done: def process_request(self, req, resp): resp.content_type = req.accept +.. _custom_media_handlers: Replacing the Default Handlers ------------------------------ @@ -121,6 +122,9 @@ Supported Handler Types .. autoclass:: falcon.media.MessagePackHandler :members: +.. autoclass:: falcon.media.URLEncodedFormHandler + :members: + Custom Handler Type ------------------- @@ -152,6 +156,7 @@ common media types, including the following: falcon.MEDIA_JSON falcon.MEDIA_MSGPACK + falcon.MEDIA_URLENCODED falcon.MEDIA_YAML falcon.MEDIA_XML falcon.MEDIA_HTML diff --git a/docs/user/faq.rst b/docs/user/faq.rst index 01fe0181a..24b02c44d 100644 --- a/docs/user/faq.rst +++ b/docs/user/faq.rst @@ -529,7 +529,34 @@ the form parameters accessible via :attr:`~.Request.params`, api.req_options.auto_parse_form_urlencoded = True -Alternatively, POSTed form parameters may be read directly from +Alternatively, :class:`falcon.media.URLEncodedFormHandler` may be +:ref:`installed <custom_media_handlers>` to handle the +``application/x-www-form-urlencoded`` content type. The form parameters can +then be simply accessed as :attr:`Request.media <falcon.Request.media>`: + +.. code:: python + + import falcon + from falcon import media + + + handlers = media.Handlers({ + falcon.MEDIA_JSON: media.JSONHandler(), + falcon.MEDIA_URLENCODED: media.URLEncodedFormHandler(), + # ... and any other request media handlers you may need + }) + + api = falcon.API() + api.req_options.media_handlers = handlers + +.. note:: + Going forward, the :attr:`~RequestOptions.auto_parse_form_urlencoded` way to + access the submitted form may be deprecated in favor of the media handler in + further development versions of Falcon 3.0 series; + :class:`falcon.media.URLEncodedFormHandler` would then be installed by + default. + +POSTed form parameters may also be read directly from :attr:`~.Request.stream` and parsed via :meth:`falcon.uri.parse_query_string` or `urllib.parse.parse_qs() <https://docs.python.org/3.6/library/urllib.parse.html#urllib.parse.parse_qs>`_. diff --git a/falcon/constants.py b/falcon/constants.py index 1c01939e8..08db4f0e3 100644 --- a/falcon/constants.py +++ b/falcon/constants.py @@ -51,6 +51,8 @@ # but the use of the 'x-' prefix is discouraged by RFC 6838. MEDIA_MSGPACK = 'application/msgpack' +MEDIA_URLENCODED = 'application/x-www-form-urlencoded' + # NOTE(kgriffs): An internet media type for YAML has not been # registered. RoR uses 'application/x-yaml', but since use of # 'x-' is discouraged by RFC 6838, we don't use it in Falcon. diff --git a/falcon/media/__init__.py b/falcon/media/__init__.py index 44cb8d853..c598c8f8b 100644 --- a/falcon/media/__init__.py +++ b/falcon/media/__init__.py @@ -1,5 +1,6 @@ from .base import BaseHandler # NOQA from .json import JSONHandler # NOQA from .msgpack import MessagePackHandler # NOQA +from .urlencoded import URLEncodedFormHandler # NOQA from .handlers import Handlers # NOQA diff --git a/falcon/media/urlencoded.py b/falcon/media/urlencoded.py new file mode 100644 index 000000000..95228fd4b --- /dev/null +++ b/falcon/media/urlencoded.py @@ -0,0 +1,46 @@ +from urllib.parse import urlencode + +from falcon.media.base import BaseHandler +from falcon.util.uri import parse_query_string + + +class URLEncodedFormHandler(BaseHandler): + """ + URL-encoded form data handler. + + This handler parses ``application/x-www-form-urlencoded`` HTML forms to a + ``dict`` in a similar way that URL query parameters are parsed. + + Keyword Arguments: + keep_blank (bool): Whether to keep empty-string values from the form + when deserializing. + csv (bool): Whether to split comma-separated form values into list + when deserializing. + """ + + def __init__(self, keep_blank=True, csv=False): + self.keep_blank = keep_blank + self.csv = csv + + def serialize(self, media, content_type): + # NOTE(vytas): Setting doseq to True to mirror the parse_query_string + # behaviour. + return urlencode(media, doseq=True) + + def deserialize(self, stream, content_type, content_length): + body = stream.read() + + # NOTE(kgriffs): According to http://goo.gl/6rlcux the + # body should be US-ASCII. Enforcing this also helps + # catch malicious input. + body = body.decode('ascii') + + # TODO(vytas): We are not short-circuiting here for performance (as + # empty URL-encoded payload should not be a common case), but to work + # around #1600 + if not body: + return {} + + return parse_query_string(body, + keep_blank=self.keep_blank, + csv=self.csv)	diff --git a/tests/test_media_urlencoded.py b/tests/test_media_urlencoded.py new file mode 100644 index 000000000..6f05c2c7b --- /dev/null +++ b/tests/test_media_urlencoded.py @@ -0,0 +1,70 @@ +import io + +import pytest + +import falcon +from falcon import media +from falcon import testing + + +def test_deserialize_empty_form(): + handler = media.URLEncodedFormHandler() + stream = io.BytesIO(b'') + assert handler.deserialize(stream, falcon.MEDIA_URLENCODED, 0) == {} + + +def test_deserialize_invalid_unicode(): + handler = media.URLEncodedFormHandler() + stream = io.BytesIO('spade=♠'.encode()) + with pytest.raises(UnicodeDecodeError): + print(handler.deserialize(stream, falcon.MEDIA_URLENCODED, 9)) + + +@pytest.mark.parametrize('data,expected', [ + ({'hello': 'world'}, 'hello=world'), + ({'number': [1, 2]}, 'number=1&number=2'), +]) +def test_urlencoded_form_handler_serialize(data, expected): + handler = media.URLEncodedFormHandler() + assert handler.serialize(data, falcon.MEDIA_URLENCODED) == expected + + +class MediaMirror: + + def on_post(self, req, resp): + resp.media = req.media + + +@pytest.fixture +def client(): + handlers = media.Handlers({ + falcon.MEDIA_JSON: media.JSONHandler(), + falcon.MEDIA_URLENCODED: media.URLEncodedFormHandler(), + }) + api = falcon.API() + api.req_options.media_handlers = handlers + api.resp_options.media_handlers = handlers + + api.add_route('/media', MediaMirror()) + + return testing.TestClient(api) + + +def test_empty_form(client): + resp = client.simulate_post( + '/media', + headers={'Content-Type': 'application/x-www-form-urlencoded'}) + assert resp.content == b'' + + +@pytest.mark.parametrize('body,expected', [ + ('a=1&b=&c=3', {'a': '1', 'b': '', 'c': '3'}), + ('param=undefined', {'param': 'undefined'}), + ('color=green&color=black', {'color': ['green', 'black']}), +]) +def test_urlencoded_form(client, body, expected): + resp = client.simulate_post( + '/media', + body=body, + headers={'Content-Type': 'application/x-www-form-urlencoded'}) + assert resp.json == expected	diff --git a/docs/_newsfragments/urlencoded-form-media-handler.feature.rst b/docs/_newsfragments/urlencoded-form-media-handler.feature.rst new file mode 100644 index 000000000..9350c3745 --- /dev/null +++ b/docs/_newsfragments/urlencoded-form-media-handler.feature.rst @@ -0,0 +1,2 @@ +``URLEncodedFormHandler`` was added for handling URL-encoded forms (of content +type ``application/x-www-form-urlencoded``) as ``Request.media``. diff --git a/docs/api/media.rst b/docs/api/media.rst index 90c7d3e27..06ec16618 100644 --- a/docs/api/media.rst +++ b/docs/api/media.rst @@ -67,6 +67,7 @@ middleware. Here is an example of how this can be done: def process_request(self, req, resp): resp.content_type = req.accept +.. _custom_media_handlers: Replacing the Default Handlers ------------------------------ @@ -121,6 +122,9 @@ Supported Handler Types .. autoclass:: falcon.media.MessagePackHandler :members: +.. autoclass:: falcon.media.URLEncodedFormHandler + :members: + Custom Handler Type ------------------- @@ -152,6 +156,7 @@ common media types, including the following: falcon.MEDIA_JSON falcon.MEDIA_MSGPACK + falcon.MEDIA_URLENCODED falcon.MEDIA_YAML falcon.MEDIA_XML falcon.MEDIA_HTML diff --git a/docs/user/faq.rst b/docs/user/faq.rst index 01fe0181a..24b02c44d 100644 --- a/docs/user/faq.rst +++ b/docs/user/faq.rst @@ -529,7 +529,34 @@ the form parameters accessible via :attr:`~.Request.params`, api.req_options.auto_parse_form_urlencoded = True -Alternatively, POSTed form parameters may be read directly from +Alternatively, :class:`falcon.media.URLEncodedFormHandler` may be +:ref:`installed <custom_media_handlers>` to handle the +``application/x-www-form-urlencoded`` content type. The form parameters can +then be simply accessed as :attr:`Request.media <falcon.Request.media>`: + +.. code:: python + + import falcon + from falcon import media + + + handlers = media.Handlers({ + falcon.MEDIA_JSON: media.JSONHandler(), + falcon.MEDIA_URLENCODED: media.URLEncodedFormHandler(), + # ... and any other request media handlers you may need + }) + + api = falcon.API() + api.req_options.media_handlers = handlers + +.. note:: + Going forward, the :attr:`~RequestOptions.auto_parse_form_urlencoded` way to + access the submitted form may be deprecated in favor of the media handler in + further development versions of Falcon 3.0 series; + :class:`falcon.media.URLEncodedFormHandler` would then be installed by + default. + +POSTed form parameters may also be read directly from :attr:`~.Request.stream` and parsed via :meth:`falcon.uri.parse_query_string` or `urllib.parse.parse_qs() <https://docs.python.org/3.6/library/urllib.parse.html#urllib.parse.parse_qs>`_.	[ { "components": [ { "doc": "URL-encoded form data handler.\n\nThis handler parses ``application/x-www-form-urlencoded`` HTML forms to a\n``dict`` in a similar way that URL query parameters are parsed.\n\nKeyword Arguments:\n keep_blank (bool): Whether to keep empty-string values from the form\n...	[ "tests/test_media_urlencoded.py::test_deserialize_empty_form", "tests/test_media_urlencoded.py::test_deserialize_invalid_unicode", "tests/test_media_urlencoded.py::test_urlencoded_form_handler_serialize[data0-hello=world]", "tests/test_media_urlencoded.py::test_urlencoded_form_handler_serialize[data1-number=1...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat(media): add URL-encoded form data handler ~~Just dropping a quick sketch from PyCon sprints, this still a bit rough on edges.~~ We could probably polish documentation & recipes etc, but otherwise this is ready to review as in proposal for inclusion in Falcon 3.0 alpha1. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in falcon/media/urlencoded.py] (definition of URLEncodedFormHandler:) class URLEncodedFormHandler(BaseHandler): """URL-encoded form data handler. This handler parses ``application/x-www-form-urlencoded`` HTML forms to a ``dict`` in a similar way that URL query parameters are parsed. Keyword Arguments: keep_blank (bool): Whether to keep empty-string values from the form when deserializing. csv (bool): Whether to split comma-separated form values into list when deserializing.""" (definition of URLEncodedFormHandler.__init__:) def __init__(self, keep_blank=True, csv=False): (definition of URLEncodedFormHandler.serialize:) def serialize(self, media, content_type): (definition of URLEncodedFormHandler.deserialize:) def deserialize(self, stream, content_type, content_length): [end of new definitions in falcon/media/urlencoded.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		77d5e6394a88ead151c9469494749f95f06b24bf
falconry__falcon-1523	1,523	falconry/falcon	null	0fa55df85849650e6929152887d63f666e4389d4	2019-05-06T18:20:18Z	diff --git a/docs/api/cors.rst b/docs/api/cors.rst new file mode 100644 index 000000000..e67af1650 --- /dev/null +++ b/docs/api/cors.rst @@ -0,0 +1,34 @@ +.. _cors: + +CORS +===== + +`Cross Origin Resource Sharing <https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS>`_ +(CORS) is an additional security check performed by modern +browsers to prevent unauthorized requests between different domains. + +When implementing +a web API, it is common to have to also implement a CORS policy. Therefore, +Falcon provides an easy way to enable a simple CORS policy via a flag passed +to :any:`falcon.API`. + +By default, Falcon's built-in CORS support is disabled, so that any cross-origin +requests will be blocked by the browser. Passing ``cors_enabled=True`` will +cause the framework to include the necessary response headers to allow access +from any origin to any route in the app. Individual responders may override this +behavior by setting the Access-Control-Allow-Origin header explicitly. + +Whether or not you implement a CORS policy, we recommend also putting a robust +AuthN/Z layer in place to authorize individual clients, as needed, to protect +sensitive resources. + +Usage +----- + +.. code:: python + + import falcon + + # Enable a simple CORS policy for all routes + app = falcon.API(cors_enable=True) + diff --git a/docs/api/index.rst b/docs/api/index.rst index 3e6e72d93..52622f88d 100644 --- a/docs/api/index.rst +++ b/docs/api/index.rst @@ -12,6 +12,7 @@ Classes and Functions media redirects middleware + cors hooks routing util diff --git a/falcon/api.py b/falcon/api.py index b6146a282..43f9a7edd 100644 --- a/falcon/api.py +++ b/falcon/api.py @@ -20,6 +20,7 @@ from falcon import api_helpers as helpers, DEFAULT_MEDIA_TYPE, routing from falcon.http_error import HTTPError from falcon.http_status import HTTPStatus +from falcon.middlewares import CORSMiddleware from falcon.request import Request, RequestOptions import falcon.responders from falcon.response import Response, ResponseOptions @@ -136,6 +137,11 @@ def process_response(self, req, resp, resource, req_succeeded) when that same component's ``process_request()`` (or that of a component higher up in the stack) raises an exception. + cors_enable (bool): Set this flag to ``True`` to enable a simple + CORS policy for all routes, including support for preflighted + requests (default ``False``). + (See also: :ref:`CORS <cors>`) + Attributes: req_options: A set of behavioral options related to incoming requests. (See also: :py:class:`~.RequestOptions`) @@ -155,16 +161,34 @@ def process_response(self, req, resp, resource, req_succeeded) '_error_handlers', '_media_type', '_router', '_sinks', '_serialize_error', 'req_options', 'resp_options', '_middleware', '_independent_middleware', '_router_search', - '_static_routes') + '_static_routes', '_cors_enable') def __init__(self, media_type=DEFAULT_MEDIA_TYPE, request_type=Request, response_type=Response, middleware=None, router=None, - independent_middleware=True): + independent_middleware=True, cors_enable=False): self._sinks = [] self._media_type = media_type self._static_routes = [] + if cors_enable: + cm = CORSMiddleware() + + if middleware is None: + middleware = [cm] + else: + try: + # NOTE(kgriffs): Check to see if middleware is an + # iterable, and if so, append the CORSMiddleware + # instance. + iter(middleware) + middleware = list(middleware) + middleware.append(cm) + except TypeError: + # NOTE(kgriffs): Assume the middleware kwarg references + # a single middleware component. + middleware = [middleware, cm] + # set middleware self._middleware = helpers.prepare_middleware( middleware, independent_middleware=independent_middleware) @@ -204,7 +228,6 @@ def __call__(self, env, start_response): # noqa: C901 status and headers on a response. """ - req = self._request_type(env, options=self.req_options) resp = self._response_type(options=self.resp_options) resource = None diff --git a/falcon/middlewares.py b/falcon/middlewares.py new file mode 100644 index 000000000..97fb8dfad --- /dev/null +++ b/falcon/middlewares.py @@ -0,0 +1,29 @@ + +class CORSMiddleware(object): + def process_response(self, req, resp, resource, req_succeeded): + """Implement a simple blanket CORS policy for all routes. + + This middleware provides a simple out-of-the box CORS policy, + including handling of preflighted requests from the browser. + + See also: https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS + """ + + if resp.get_header('Access-Control-Allow-Origin') is None: + resp.set_header('Access-Control-Allow-Origin', '') + + if (req_succeeded and + req.method == 'OPTIONS' and + req.get_header('Access-Control-Request-Method')): + + # NOTE(kgriffs): This is a CORS preflight request. Patch the + # response accordingly. + + allow = resp.get_header('Allow') + resp.delete_header('Allow') + + allow_headers = req.get_header('Access-Control-Request-Headers', default='') + + resp.set_header('Access-Control-Allow-Methods', allow) + resp.set_header('Access-Control-Allow-Headers', allow_headers) + resp.set_header('Access-Control-Max-Age', '86400') # 24 hours	diff --git a/tests/test_headers.py b/tests/test_headers.py index 1ee19c8ac..1c2951498 100644 --- a/tests/test_headers.py +++ b/tests/test_headers.py @@ -16,6 +16,12 @@ def client(): return testing.TestClient(app) +@pytest.fixture(scope='function') +def cors_client(): + app = falcon.API(cors_enable=True) + return testing.TestClient(app) + + class XmlResource: def __init__(self, content_type): self.content_type = content_type @@ -233,6 +239,16 @@ def on_get(self, req, resp): resp.expires = self._expires +class CORSHeaderResource: + + def on_get(self, req, resp): + resp.body = "I'm a CORS test response" + + def on_delete(self, req, resp): + resp.set_header('Access-Control-Allow-Origin', 'example.com') + resp.body = "I'm a CORS test response" + + class TestHeaders: def test_content_length(self, client): @@ -691,6 +707,46 @@ def test_content_length_options(self, client): content_length = '0' assert result.headers['Content-Length'] == content_length + def test_disabled_cors_should_not_add_any_extra_headers(self, client): + client.app.add_route('/', CORSHeaderResource()) + result = client.simulate_get() + assert 'Access-Control-Allow-Origin'.lower() not in dict( + result.headers.lower_items()).keys() + + def test_enabled_cors_should_add_extra_headers_on_response(self, cors_client): + cors_client.app.add_route('/', CORSHeaderResource()) + result = cors_client.simulate_get() + assert 'Access-Control-Allow-Origin'.lower() in dict( + result.headers.lower_items()).keys() + + def test_enabled_cors_should_accept_all_origins_requests(self, cors_client): + cors_client.app.add_route('/', CORSHeaderResource()) + + result = cors_client.simulate_get() + assert result.headers['Access-Control-Allow-Origin'] == '' + + result = cors_client.simulate_delete() + assert result.headers['Access-Control-Allow-Origin'] == 'example.com' + + def test_enabled_cors_handles_preflighting(self, cors_client): + cors_client.app.add_route('/', CORSHeaderResource()) + result = cors_client.simulate_options(headers=( + ('Access-Control-Request-Method', 'GET'), + ('Access-Control-Request-Headers', 'X-PINGOTHER, Content-Type'), + )) + assert result.headers['Access-Control-Allow-Methods'] == 'DELETE, GET' + assert result.headers['Access-Control-Allow-Headers'] == 'X-PINGOTHER, Content-Type' + assert result.headers['Access-Control-Max-Age'] == '86400' # 24 hours in seconds + + def test_enabled_cors_handles_preflighting_no_headers_in_req(self, cors_client): + cors_client.app.add_route('/', CORSHeaderResource()) + result = cors_client.simulate_options(headers=( + ('Access-Control-Request-Method', 'POST'), + )) + assert result.headers['Access-Control-Allow-Methods'] == 'DELETE, GET' + assert result.headers['Access-Control-Allow-Headers'] == '' + assert result.headers['Access-Control-Max-Age'] == '86400' # 24 hours in seconds + # ---------------------------------------------------------------------- # Helpers # ---------------------------------------------------------------------- diff --git a/tests/test_middleware.py b/tests/test_middleware.py index 4e2d31ffe..008cf2172 100644 --- a/tests/test_middleware.py +++ b/tests/test_middleware.py @@ -137,6 +137,12 @@ def process_response(self): pass +class TestCorsResource: + def on_get(self, req, resp, *kwargs): + resp.status = falcon.HTTP_200 + resp.body = 'Test' + + class TestMiddleware: def setup_method(self, method): # Clear context @@ -804,3 +810,19 @@ def test_process_resource_cached(self, independent_middleware): # NOTE(kgriffs): Short-circuiting does not affect process_response() assert 'end_time' in context + + +class TestCORSMiddlewareWithAnotherMiddleware(TestMiddleware): + + @pytest.mark.parametrize('mw', [ + CaptureResponseMiddleware(), + [CaptureResponseMiddleware()], + (CaptureResponseMiddleware(),), + iter([CaptureResponseMiddleware()]), + ]) + def test_api_initialization_with_cors_enabled_and_middleware_param(self, mw): + app = falcon.API(middleware=mw, cors_enable=True) + app.add_route('/', TestCorsResource()) + client = testing.TestClient(app) + result = client.simulate_get() + assert result.headers['Access-Control-Allow-Origin'] == ''	diff --git a/docs/api/cors.rst b/docs/api/cors.rst new file mode 100644 index 000000000..e67af1650 --- /dev/null +++ b/docs/api/cors.rst @@ -0,0 +1,34 @@ +.. _cors: + +CORS +===== + +`Cross Origin Resource Sharing <https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS>`_ +(CORS) is an additional security check performed by modern +browsers to prevent unauthorized requests between different domains. + +When implementing +a web API, it is common to have to also implement a CORS policy. Therefore, +Falcon provides an easy way to enable a simple CORS policy via a flag passed +to :any:`falcon.API`. + +By default, Falcon's built-in CORS support is disabled, so that any cross-origin +requests will be blocked by the browser. Passing ``cors_enabled=True`` will +cause the framework to include the necessary response headers to allow access +from any origin to any route in the app. Individual responders may override this +behavior by setting the Access-Control-Allow-Origin header explicitly. + +Whether or not you implement a CORS policy, we recommend also putting a robust +AuthN/Z layer in place to authorize individual clients, as needed, to protect +sensitive resources. + +Usage +----- + +.. code:: python + + import falcon + + # Enable a simple CORS policy for all routes + app = falcon.API(cors_enable=True) + diff --git a/docs/api/index.rst b/docs/api/index.rst index 3e6e72d93..52622f88d 100644 --- a/docs/api/index.rst +++ b/docs/api/index.rst @@ -12,6 +12,7 @@ Classes and Functions media redirects middleware + cors hooks routing util	[ { "components": [ { "doc": "", "lines": [ 2, 29 ], "name": "CORSMiddleware", "signature": "class CORSMiddleware(object):", "type": "class" }, { "doc": "Implement a simple blanket CORS policy for all routes.\n\nThis mid...	[ "tests/test_headers.py::TestHeaders::test_enabled_cors_should_add_extra_headers_on_response", "tests/test_headers.py::TestHeaders::test_enabled_cors_should_accept_all_origins_requests", "tests/test_headers.py::TestHeaders::test_enabled_cors_handles_preflighting", "tests/test_headers.py::TestHeaders::test_enab...	[ "tests/test_headers.py::TestHeaders::test_content_length", "tests/test_headers.py::TestHeaders::test_declared_content_length_on_head", "tests/test_headers.py::TestHeaders::test_declared_content_length_overridden_by_no_body", "tests/test_headers.py::TestHeaders::test_declared_content_length_overriden_by_body_l...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat(API): Adding the flag to handle basic CORS policies in the framework Added a new flag to `falcon.API` class init method in order to turn on/off feature to handle basic CORS policies in the framework. By default, it will come off so all request must meet CORS policies. Addresses: #1194 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in falcon/middlewares.py] (definition of CORSMiddleware:) class CORSMiddleware(object): (definition of CORSMiddleware.process_response:) def process_response(self, req, resp, resource, req_succeeded): """Implement a simple blanket CORS policy for all routes. This middleware provides a simple out-of-the box CORS policy, including handling of preflighted requests from the browser. See also: https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS""" [end of new definitions in falcon/middlewares.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		77d5e6394a88ead151c9469494749f95f06b24bf
scikit-learn__scikit-learn-13806	13,806	scikit-learn/scikit-learn	0.22	9adba491a209b2768274cd7f0499c6e41df8c8fa	2019-05-06T14:14:55Z	diff --git a/doc/whats_new/v0.22.rst b/doc/whats_new/v0.22.rst index 0518d6c9e0de4..44606556e7469 100644 --- a/doc/whats_new/v0.22.rst +++ b/doc/whats_new/v0.22.rst @@ -47,6 +47,12 @@ Changelog of the maximization procedure in :term:`fit`. :pr:`13618` by :user:`Yoshihiro Uchida <c56pony>`. +:mod:`sklearn.pipeline` +....................... + +- \|Enhancement\| :class:`pipeline.Pipeline` now supports :term:`score_samples` if + the final estimator does. + :pr:`13806` by :user:`Anaël Beaugnon <ab-anssi>`. :mod:`sklearn.svm` .................. diff --git a/sklearn/pipeline.py b/sklearn/pipeline.py index 55df0de701db4..00f087d83f881 100644 --- a/sklearn/pipeline.py +++ b/sklearn/pipeline.py @@ -491,6 +491,25 @@ def decision_function(self, X): Xt = transform.transform(Xt) return self.steps[-1][-1].decision_function(Xt) + @if_delegate_has_method(delegate='_final_estimator') + def score_samples(self, X): + """Apply transforms, and score_samples of the final estimator. + + Parameters + ---------- + X : iterable + Data to predict on. Must fulfill input requirements of first step + of the pipeline. + + Returns + ------- + y_score : ndarray, shape (n_samples,) + """ + Xt = X + for _, _, transformer in self._iter(with_final=False): + Xt = transformer.transform(Xt) + return self.steps[-1][-1].score_samples(Xt) + @if_delegate_has_method(delegate='_final_estimator') def predict_log_proba(self, X): """Apply transforms, and predict_log_proba of the final estimator	diff --git a/sklearn/tests/test_pipeline.py b/sklearn/tests/test_pipeline.py index bae3f0080da35..c8df039e347c6 100644 --- a/sklearn/tests/test_pipeline.py +++ b/sklearn/tests/test_pipeline.py @@ -16,6 +16,7 @@ from sklearn.utils.testing import assert_raises_regex from sklearn.utils.testing import assert_raise_message from sklearn.utils.testing import assert_equal +from sklearn.utils.testing import assert_allclose from sklearn.utils.testing import assert_array_equal from sklearn.utils.testing import assert_array_almost_equal from sklearn.utils.testing import assert_dict_equal @@ -24,6 +25,7 @@ from sklearn.base import clone, BaseEstimator from sklearn.pipeline import Pipeline, FeatureUnion, make_pipeline, make_union from sklearn.svm import SVC +from sklearn.neighbors import LocalOutlierFactor from sklearn.linear_model import LogisticRegression, Lasso from sklearn.linear_model import LinearRegression from sklearn.cluster import KMeans @@ -330,6 +332,36 @@ def test_pipeline_methods_pca_svm(): pipe.score(X, y) +def test_pipeline_score_samples_pca_lof(): + iris = load_iris() + X = iris.data + # Test that the score_samples method is implemented on a pipeline. + # Test that the score_samples method on pipeline yields same results as + # applying transform and score_samples steps separately. + pca = PCA(svd_solver='full', n_components='mle', whiten=True) + lof = LocalOutlierFactor(novelty=True) + pipe = Pipeline([('pca', pca), ('lof', lof)]) + pipe.fit(X) + # Check the shapes + assert pipe.score_samples(X).shape == (X.shape[0],) + # Check the values + lof.fit(pca.fit_transform(X)) + assert_allclose(pipe.score_samples(X), lof.score_samples(pca.transform(X))) + + +def test_score_samples_on_pipeline_without_score_samples(): + X = np.array([[1], [2]]) + y = np.array([1, 2]) + # Test that a pipeline does not have score_samples method when the final + # step of the pipeline does not have score_samples defined. + pipe = make_pipeline(LogisticRegression()) + pipe.fit(X, y) + with pytest.raises(AttributeError, + match="'LogisticRegression' object has no attribute " + "'score_samples'"): + pipe.score_samples(X) + + def test_pipeline_methods_preprocessing_svm(): # Test the various methods of the pipeline (preprocessing + svm). iris = load_iris()	diff --git a/doc/whats_new/v0.22.rst b/doc/whats_new/v0.22.rst index 0518d6c9e0de4..44606556e7469 100644 --- a/doc/whats_new/v0.22.rst +++ b/doc/whats_new/v0.22.rst @@ -47,6 +47,12 @@ Changelog of the maximization procedure in :term:`fit`. :pr:`13618` by :user:`Yoshihiro Uchida <c56pony>`. +:mod:`sklearn.pipeline` +....................... + +- \|Enhancement\| :class:`pipeline.Pipeline` now supports :term:`score_samples` if + the final estimator does. + :pr:`13806` by :user:`Anaël Beaugnon <ab-anssi>`. :mod:`sklearn.svm` ..................	[ { "components": [ { "doc": "Apply transforms, and score_samples of the final estimator.\n\nParameters\n----------\nX : iterable\n Data to predict on. Must fulfill input requirements of first step\n of the pipeline.\n\nReturns\n-------\ny_score : ndarray, shape (n_samples,)", "lines":...	[ "sklearn/tests/test_pipeline.py::test_pipeline_score_samples_pca_lof", "sklearn/tests/test_pipeline.py::test_score_samples_on_pipeline_without_score_samples" ]	[ "sklearn/tests/test_pipeline.py::test_pipeline_init", "sklearn/tests/test_pipeline.py::test_pipeline_init_tuple", "sklearn/tests/test_pipeline.py::test_pipeline_methods_anova", "sklearn/tests/test_pipeline.py::test_pipeline_fit_params", "sklearn/tests/test_pipeline.py::test_pipeline_sample_weight_supported"...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG] Add function score_samples to Pipeline (fix issue #12542) #### Reference Issues/PRs Fix issue #12542. #### What does this implement/fix? Explain your changes. The pull request adds a function `score_samples` to the `Pipeline`, `GridSearchCV`, and `RandomizedSearchCV`classes (code very similar to the functions `predict_proba`, `decision_function`, `predict_log_proba`). ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/pipeline.py] (definition of Pipeline.score_samples:) def score_samples(self, X): """Apply transforms, and score_samples of the final estimator. Parameters ---------- X : iterable Data to predict on. Must fulfill input requirements of first step of the pipeline. Returns ------- y_score : ndarray, shape (n_samples,)""" [end of new definitions in sklearn/pipeline.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c96e0958da46ebef482a4084cdda3285d5f5ad23
pydata__xarray-2922	2,922	pydata/xarray	0.12	65a5bff79479c4b56d6f733236fe544b7f4120a8	2019-04-26T17:09:02Z	diff --git a/doc/api.rst b/doc/api.rst index 4492d882355..43a9cf53ead 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -165,6 +165,7 @@ Computation Dataset.groupby_bins Dataset.rolling Dataset.rolling_exp + Dataset.weighted Dataset.coarsen Dataset.resample Dataset.diff @@ -340,6 +341,7 @@ Computation DataArray.groupby_bins DataArray.rolling DataArray.rolling_exp + DataArray.weighted DataArray.coarsen DataArray.dt DataArray.resample @@ -577,6 +579,22 @@ Rolling objects core.rolling.DatasetRolling.reduce core.rolling_exp.RollingExp +Weighted objects +================ + +.. autosummary:: + :toctree: generated/ + + core.weighted.DataArrayWeighted + core.weighted.DataArrayWeighted.mean + core.weighted.DataArrayWeighted.sum + core.weighted.DataArrayWeighted.sum_of_weights + core.weighted.DatasetWeighted + core.weighted.DatasetWeighted.mean + core.weighted.DatasetWeighted.sum + core.weighted.DatasetWeighted.sum_of_weights + + Coarsen objects =============== diff --git a/doc/computation.rst b/doc/computation.rst index 1ac30f55ee7..5309f27e9b6 100644 --- a/doc/computation.rst +++ b/doc/computation.rst @@ -1,3 +1,5 @@ +.. currentmodule:: xarray + .. _comput: ########### @@ -241,12 +243,94 @@ You can also use ``construct`` to compute a weighted rolling sum: To avoid this, use ``skipna=False`` as the above example. +.. _comput.weighted: + +Weighted array reductions +========================= + +:py:class:`DataArray` and :py:class:`Dataset` objects include :py:meth:`DataArray.weighted` +and :py:meth:`Dataset.weighted` array reduction methods. They currently +support weighted ``sum`` and weighted ``mean``. + +.. ipython:: python + + coords = dict(month=('month', [1, 2, 3])) + + prec = xr.DataArray([1.1, 1.0, 0.9], dims=('month', ), coords=coords) + weights = xr.DataArray([31, 28, 31], dims=('month', ), coords=coords) + +Create a weighted object: + +.. ipython:: python + + weighted_prec = prec.weighted(weights) + weighted_prec + +Calculate the weighted sum: + +.. ipython:: python + + weighted_prec.sum() + +Calculate the weighted mean: + +.. ipython:: python + + weighted_prec.mean(dim="month") + +The weighted sum corresponds to: + +.. ipython:: python + + weighted_sum = (prec * weights).sum() + weighted_sum + +and the weighted mean to: + +.. ipython:: python + + weighted_mean = weighted_sum / weights.sum() + weighted_mean + +However, the functions also take missing values in the data into account: + +.. ipython:: python + + data = xr.DataArray([np.NaN, 2, 4]) + weights = xr.DataArray([8, 1, 1]) + + data.weighted(weights).mean() + +Using ``(data * weights).sum() / weights.sum()`` would (incorrectly) result +in 0.6. + + +If the weights add up to to 0, ``sum`` returns 0: + +.. ipython:: python + + data = xr.DataArray([1.0, 1.0]) + weights = xr.DataArray([-1.0, 1.0]) + + data.weighted(weights).sum() + +and ``mean`` returns ``NaN``: + +.. ipython:: python + + data.weighted(weights).mean() + + +.. note:: + ``weights`` must be a :py:class:`DataArray` and cannot contain missing values. + Missing values can be replaced manually by ``weights.fillna(0)``. + .. _comput.coarsen: Coarsen large arrays ==================== -``DataArray`` and ``Dataset`` objects include a +:py:class:`DataArray` and :py:class:`Dataset` objects include a :py:meth:`~xarray.DataArray.coarsen` and :py:meth:`~xarray.Dataset.coarsen` methods. This supports the block aggregation along multiple dimensions, diff --git a/doc/examples.rst b/doc/examples.rst index 805395808e0..1d48d29bcc5 100644 --- a/doc/examples.rst +++ b/doc/examples.rst @@ -6,6 +6,7 @@ Examples examples/weather-data examples/monthly-means + examples/area_weighted_temperature examples/multidimensional-coords examples/visualization_gallery examples/ROMS_ocean_model diff --git a/doc/examples/area_weighted_temperature.ipynb b/doc/examples/area_weighted_temperature.ipynb new file mode 100644 index 00000000000..72876e3fc29 --- /dev/null +++ b/doc/examples/area_weighted_temperature.ipynb @@ -0,0 +1,226 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "toc": true + }, + "source": [ + "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n", + "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Compare-weighted-and-unweighted-mean-temperature\" data-toc-modified-id=\"Compare-weighted-and-unweighted-mean-temperature-1\"><span class=\"toc-item-num\">1  </span>Compare weighted and unweighted mean temperature</a></span><ul class=\"toc-item\"><li><ul class=\"toc-item\"><li><span><a href=\"#Data\" data-toc-modified-id=\"Data-1.0.1\"><span class=\"toc-item-num\">1.0.1  </span>Data</a></span></li><li><span><a href=\"#Creating-weights\" data-toc-modified-id=\"Creating-weights-1.0.2\"><span class=\"toc-item-num\">1.0.2  </span>Creating weights</a></span></li><li><span><a href=\"#Weighted-mean\" data-toc-modified-id=\"Weighted-mean-1.0.3\"><span class=\"toc-item-num\">1.0.3  </span>Weighted mean</a></span></li><li><span><a href=\"#Plot:-comparison-with-unweighted-mean\" data-toc-modified-id=\"Plot:-comparison-with-unweighted-mean-1.0.4\"><span class=\"toc-item-num\">1.0.4  </span>Plot: comparison with unweighted mean</a></span></li></ul></li></ul></li></ul></div>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Compare weighted and unweighted mean temperature\n", + "\n", + "\n", + "Author: [Mathias Hauser](https://github.com/mathause/)\n", + "\n", + "\n", + "We use the `air_temperature` example dataset to calculate the area-weighted temperature over its domain. This dataset has a regular latitude/ longitude grid, thus the gridcell area decreases towards the pole. For this grid we can use the cosine of the latitude as proxy for the grid cell area.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:43:57.222351Z", + "start_time": "2020-03-17T14:43:56.147541Z" + } + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import cartopy.crs as ccrs\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "import xarray as xr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data\n", + "\n", + "Load the data, convert to celsius, and resample to daily values" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:43:57.831734Z", + "start_time": "2020-03-17T14:43:57.651845Z" + } + }, + "outputs": [], + "source": [ + "ds = xr.tutorial.load_dataset(\"air_temperature\")\n", + "\n", + "# to celsius\n", + "air = ds.air - 273.15\n", + "\n", + "# resample from 6-hourly to daily values\n", + "air = air.resample(time=\"D\").mean()\n", + "\n", + "air" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the first timestep:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:43:59.887120Z", + "start_time": "2020-03-17T14:43:59.582894Z" + } + }, + "outputs": [], + "source": [ + "projection = ccrs.LambertConformal(central_longitude=-95, central_latitude=45)\n", + "\n", + "f, ax = plt.subplots(subplot_kw=dict(projection=projection))\n", + "\n", + "air.isel(time=0).plot(transform=ccrs.PlateCarree(), cbar_kwargs=dict(shrink=0.7))\n", + "ax.coastlines()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creating weights\n", + "\n", + "For a for a rectangular grid the cosine of the latitude is proportional to the grid cell area." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:44:18.777092Z", + "start_time": "2020-03-17T14:44:18.736587Z" + } + }, + "outputs": [], + "source": [ + "weights = np.cos(np.deg2rad(air.lat))\n", + "weights.name = \"weights\"\n", + "weights" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Weighted mean" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:44:52.607120Z", + "start_time": "2020-03-17T14:44:52.564674Z" + } + }, + "outputs": [], + "source": [ + "air_weighted = air.weighted(weights)\n", + "air_weighted" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:44:54.334279Z", + "start_time": "2020-03-17T14:44:54.280022Z" + } + }, + "outputs": [], + "source": [ + "weighted_mean = air_weighted.mean((\"lon\", \"lat\"))\n", + "weighted_mean" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot: comparison with unweighted mean\n", + "\n", + "Note how the weighted mean temperature is higher than the unweighted." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:45:08.877307Z", + "start_time": "2020-03-17T14:45:08.673383Z" + } + }, + "outputs": [], + "source": [ + "weighted_mean.plot(label=\"weighted\")\n", + "air.mean((\"lon\", \"lat\")).plot(label=\"unweighted\")\n", + "\n", + "plt.legend()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.6" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": true, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/whats-new.rst b/doc/whats-new.rst index aad0e083a8c..5640e872bea 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -25,6 +25,9 @@ Breaking changes New Features ~~~~~~~~~~~~ +- Weighted array reductions are now supported via the new :py:meth:`DataArray.weighted` + and :py:meth:`Dataset.weighted` methods. See :ref:`comput.weighted`. (:issue:`422`, :pull:`2922`). + By `Mathias Hauser <https://github.com/mathause>`_ - Added support for :py:class:`pandas.DatetimeIndex`-style rounding of ``cftime.datetime`` objects directly via a :py:class:`CFTimeIndex` or via the :py:class:`~core.accessor_dt.DatetimeAccessor`. diff --git a/xarray/core/common.py b/xarray/core/common.py index 39aa7982091..a003642076f 100644 --- a/xarray/core/common.py +++ b/xarray/core/common.py @@ -745,6 +745,25 @@ def groupby_bins( }, ) + def weighted(self, weights): + """ + Weighted operations. + + Parameters + ---------- + weights : DataArray + An array of weights associated with the values in this Dataset. + Each value in the data contributes to the reduction operation + according to its associated weight. + + Notes + ----- + ``weights`` must be a DataArray and cannot contain missing values. + Missing values can be replaced by ``weights.fillna(0)``. + """ + + return self._weighted_cls(self, weights) + def rolling( self, dim: Mapping[Hashable, int] = None, diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py index b335eeb293b..4b3ecb2744c 100644 --- a/xarray/core/dataarray.py +++ b/xarray/core/dataarray.py @@ -33,6 +33,7 @@ resample, rolling, utils, + weighted, ) from .accessor_dt import CombinedDatetimelikeAccessor from .accessor_str import StringAccessor @@ -258,6 +259,7 @@ class DataArray(AbstractArray, DataWithCoords): _rolling_cls = rolling.DataArrayRolling _coarsen_cls = rolling.DataArrayCoarsen _resample_cls = resample.DataArrayResample + _weighted_cls = weighted.DataArrayWeighted dt = property(CombinedDatetimelikeAccessor) diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index d5ad1123a54..c10447f6d11 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -46,6 +46,7 @@ resample, rolling, utils, + weighted, ) from .alignment import _broadcast_helper, _get_broadcast_dims_map_common_coords, align from .common import ( @@ -457,6 +458,7 @@ class Dataset(Mapping, ImplementsDatasetReduce, DataWithCoords): _rolling_cls = rolling.DatasetRolling _coarsen_cls = rolling.DatasetCoarsen _resample_cls = resample.DatasetResample + _weighted_cls = weighted.DatasetWeighted def __init__( self, diff --git a/xarray/core/weighted.py b/xarray/core/weighted.py new file mode 100644 index 00000000000..996d2e4c43e --- /dev/null +++ b/xarray/core/weighted.py @@ -0,0 +1,255 @@ +from typing import TYPE_CHECKING, Hashable, Iterable, Optional, Union, overload + +from .computation import dot +from .options import _get_keep_attrs + +if TYPE_CHECKING: + from .dataarray import DataArray, Dataset + +_WEIGHTED_REDUCE_DOCSTRING_TEMPLATE = """ + Reduce this {cls}'s data by a weighted ``{fcn}`` along some dimension(s). + + Parameters + ---------- + dim : str or sequence of str, optional + Dimension(s) over which to apply the weighted ``{fcn}``. + skipna : bool, optional + If True, skip missing values (as marked by NaN). By default, only + skips missing values for float dtypes; other dtypes either do not + have a sentinel missing value (int) or skipna=True has not been + implemented (object, datetime64 or timedelta64). + keep_attrs : bool, optional + If True, the attributes (``attrs``) will be copied from the original + object to the new one. If False (default), the new object will be + returned without attributes. + + Returns + ------- + reduced : {cls} + New {cls} object with weighted ``{fcn}`` applied to its data and + the indicated dimension(s) removed. + + Notes + ----- + Returns {on_zero} if the ``weights`` sum to 0.0 along the reduced + dimension(s). + """ + +_SUM_OF_WEIGHTS_DOCSTRING = """ + Calculate the sum of weights, accounting for missing values in the data + + Parameters + ---------- + dim : str or sequence of str, optional + Dimension(s) over which to sum the weights. + keep_attrs : bool, optional + If True, the attributes (``attrs``) will be copied from the original + object to the new one. If False (default), the new object will be + returned without attributes. + + Returns + ------- + reduced : {cls} + New {cls} object with the sum of the weights over the given dimension. + """ + + +class Weighted: + """An object that implements weighted operations. + + You should create a Weighted object by using the ``DataArray.weighted`` or + ``Dataset.weighted`` methods. + + See Also + -------- + Dataset.weighted + DataArray.weighted + """ + + __slots__ = ("obj", "weights") + + @overload + def __init__(self, obj: "DataArray", weights: "DataArray") -> None: + ... + + @overload # noqa: F811 + def __init__(self, obj: "Dataset", weights: "DataArray") -> None: # noqa: F811 + ... + + def __init__(self, obj, weights): # noqa: F811 + """ + Create a Weighted object + + Parameters + ---------- + obj : DataArray or Dataset + Object over which the weighted reduction operation is applied. + weights : DataArray + An array of weights associated with the values in the obj. + Each value in the obj contributes to the reduction operation + according to its associated weight. + + Notes + ----- + ``weights`` must be a ``DataArray`` and cannot contain missing values. + Missing values can be replaced by ``weights.fillna(0)``. + """ + + from .dataarray import DataArray + + if not isinstance(weights, DataArray): + raise ValueError("`weights` must be a DataArray") + + if weights.isnull().any(): + raise ValueError( + "`weights` cannot contain missing values. " + "Missing values can be replaced by `weights.fillna(0)`." + ) + + self.obj = obj + self.weights = weights + + @staticmethod + def _reduce( + da: "DataArray", + weights: "DataArray", + dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, + skipna: Optional[bool] = None, + ) -> "DataArray": + """reduce using dot; equivalent to (da * weights).sum(dim, skipna) + + for internal use only + """ + + # need to infer dims as we use `dot` + if dim is None: + dim = ... + + # need to mask invalid values in da, as `dot` does not implement skipna + if skipna or (skipna is None and da.dtype.kind in "cfO"): + da = da.fillna(0.0) + + # `dot` does not broadcast arrays, so this avoids creating a large + # DataArray (if `weights` has additional dimensions) + # maybe add fasttrack (`(da * weights).sum(dims=dim, skipna=skipna)`) + return dot(da, weights, dims=dim) + + def _sum_of_weights( + self, da: "DataArray", dim: Optional[Union[Hashable, Iterable[Hashable]]] = None + ) -> "DataArray": + """ Calculate the sum of weights, accounting for missing values """ + + # we need to mask data values that are nan; else the weights are wrong + mask = da.notnull() + + sum_of_weights = self._reduce(mask, self.weights, dim=dim, skipna=False) + + # 0-weights are not valid + valid_weights = sum_of_weights != 0.0 + + return sum_of_weights.where(valid_weights) + + def _weighted_sum( + self, + da: "DataArray", + dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, + skipna: Optional[bool] = None, + ) -> "DataArray": + """Reduce a DataArray by a by a weighted ``sum`` along some dimension(s).""" + + return self._reduce(da, self.weights, dim=dim, skipna=skipna) + + def _weighted_mean( + self, + da: "DataArray", + dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, + skipna: Optional[bool] = None, + ) -> "DataArray": + """Reduce a DataArray by a weighted ``mean`` along some dimension(s).""" + + weighted_sum = self._weighted_sum(da, dim=dim, skipna=skipna) + + sum_of_weights = self._sum_of_weights(da, dim=dim) + + return weighted_sum / sum_of_weights + + def _implementation(self, func, dim, kwargs): + + raise NotImplementedError("Use `Dataset.weighted` or `DataArray.weighted`") + + def sum_of_weights( + self, + dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, + keep_attrs: Optional[bool] = None, + ) -> Union["DataArray", "Dataset"]: + + return self._implementation( + self._sum_of_weights, dim=dim, keep_attrs=keep_attrs + ) + + def sum( + self, + dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, + skipna: Optional[bool] = None, + keep_attrs: Optional[bool] = None, + ) -> Union["DataArray", "Dataset"]: + + return self._implementation( + self._weighted_sum, dim=dim, skipna=skipna, keep_attrs=keep_attrs + ) + + def mean( + self, + dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, + skipna: Optional[bool] = None, + keep_attrs: Optional[bool] = None, + ) -> Union["DataArray", "Dataset"]: + + return self._implementation( + self._weighted_mean, dim=dim, skipna=skipna, keep_attrs=keep_attrs + ) + + def __repr__(self): + """provide a nice str repr of our Weighted object""" + + klass = self.__class__.__name__ + weight_dims = ", ".join(self.weights.dims) + return f"{klass} with weights along dimensions: {weight_dims}" + + +class DataArrayWeighted(Weighted): + def _implementation(self, func, dim, kwargs): + + keep_attrs = kwargs.pop("keep_attrs") + if keep_attrs is None: + keep_attrs = _get_keep_attrs(default=False) + + weighted = func(self.obj, dim=dim, kwargs) + + if keep_attrs: + weighted.attrs = self.obj.attrs + + return weighted + + +class DatasetWeighted(Weighted): + def _implementation(self, func, dim, kwargs) -> "Dataset": + + return self.obj.map(func, dim=dim, **kwargs) + + +def _inject_docstring(cls, cls_name): + + cls.sum_of_weights.__doc__ = _SUM_OF_WEIGHTS_DOCSTRING.format(cls=cls_name) + + cls.sum.__doc__ = _WEIGHTED_REDUCE_DOCSTRING_TEMPLATE.format( + cls=cls_name, fcn="sum", on_zero="0" + ) + + cls.mean.__doc__ = _WEIGHTED_REDUCE_DOCSTRING_TEMPLATE.format( + cls=cls_name, fcn="mean", on_zero="NaN" + ) + + +_inject_docstring(DataArrayWeighted, "DataArray") +_inject_docstring(DatasetWeighted, "Dataset")	diff --git a/xarray/tests/test_weighted.py b/xarray/tests/test_weighted.py new file mode 100644 index 00000000000..24531215dfb --- /dev/null +++ b/xarray/tests/test_weighted.py @@ -0,0 +1,311 @@ +import numpy as np +import pytest + +import xarray as xr +from xarray import DataArray +from xarray.tests import assert_allclose, assert_equal, raises_regex + + +@pytest.mark.parametrize("as_dataset", (True, False)) +def test_weighted_non_DataArray_weights(as_dataset): + + data = DataArray([1, 2]) + if as_dataset: + data = data.to_dataset(name="data") + + with raises_regex(ValueError, "`weights` must be a DataArray"): + data.weighted([1, 2]) + + +@pytest.mark.parametrize("as_dataset", (True, False)) +@pytest.mark.parametrize("weights", ([np.nan, 2], [np.nan, np.nan])) +def test_weighted_weights_nan_raises(as_dataset, weights): + + data = DataArray([1, 2]) + if as_dataset: + data = data.to_dataset(name="data") + + with pytest.raises(ValueError, match="`weights` cannot contain missing values."): + data.weighted(DataArray(weights)) + + +@pytest.mark.parametrize( + ("weights", "expected"), + (([1, 2], 3), ([2, 0], 2), ([0, 0], np.nan), ([-1, 1], np.nan)), +) +def test_weighted_sum_of_weights_no_nan(weights, expected): + + da = DataArray([1, 2]) + weights = DataArray(weights) + result = da.weighted(weights).sum_of_weights() + + expected = DataArray(expected) + + assert_equal(expected, result) + + +@pytest.mark.parametrize( + ("weights", "expected"), + (([1, 2], 2), ([2, 0], np.nan), ([0, 0], np.nan), ([-1, 1], 1)), +) +def test_weighted_sum_of_weights_nan(weights, expected): + + da = DataArray([np.nan, 2]) + weights = DataArray(weights) + result = da.weighted(weights).sum_of_weights() + + expected = DataArray(expected) + + assert_equal(expected, result) + + +@pytest.mark.parametrize("da", ([1.0, 2], [1, np.nan], [np.nan, np.nan])) +@pytest.mark.parametrize("factor", [0, 1, 3.14]) +@pytest.mark.parametrize("skipna", (True, False)) +def test_weighted_sum_equal_weights(da, factor, skipna): + # if all weights are 'f'; weighted sum is f times the ordinary sum + + da = DataArray(da) + weights = xr.full_like(da, factor) + + expected = da.sum(skipna=skipna) * factor + result = da.weighted(weights).sum(skipna=skipna) + + assert_equal(expected, result) + + +@pytest.mark.parametrize( + ("weights", "expected"), (([1, 2], 5), ([0, 2], 4), ([0, 0], 0)) +) +def test_weighted_sum_no_nan(weights, expected): + + da = DataArray([1, 2]) + + weights = DataArray(weights) + result = da.weighted(weights).sum() + expected = DataArray(expected) + + assert_equal(expected, result) + + +@pytest.mark.parametrize( + ("weights", "expected"), (([1, 2], 4), ([0, 2], 4), ([1, 0], 0), ([0, 0], 0)) +) +@pytest.mark.parametrize("skipna", (True, False)) +def test_weighted_sum_nan(weights, expected, skipna): + + da = DataArray([np.nan, 2]) + + weights = DataArray(weights) + result = da.weighted(weights).sum(skipna=skipna) + + if skipna: + expected = DataArray(expected) + else: + expected = DataArray(np.nan) + + assert_equal(expected, result) + + +@pytest.mark.filterwarnings("ignore:Mean of empty slice") +@pytest.mark.parametrize("da", ([1.0, 2], [1, np.nan], [np.nan, np.nan])) +@pytest.mark.parametrize("skipna", (True, False)) +@pytest.mark.parametrize("factor", [1, 2, 3.14]) +def test_weighted_mean_equal_weights(da, skipna, factor): + # if all weights are equal (!= 0), should yield the same result as mean + + da = DataArray(da) + + # all weights as 1. + weights = xr.full_like(da, factor) + + expected = da.mean(skipna=skipna) + result = da.weighted(weights).mean(skipna=skipna) + + assert_equal(expected, result) + + +@pytest.mark.parametrize( + ("weights", "expected"), (([4, 6], 1.6), ([1, 0], 1.0), ([0, 0], np.nan)) +) +def test_weighted_mean_no_nan(weights, expected): + + da = DataArray([1, 2]) + weights = DataArray(weights) + expected = DataArray(expected) + + result = da.weighted(weights).mean() + + assert_equal(expected, result) + + +@pytest.mark.parametrize( + ("weights", "expected"), (([4, 6], 2.0), ([1, 0], np.nan), ([0, 0], np.nan)) +) +@pytest.mark.parametrize("skipna", (True, False)) +def test_weighted_mean_nan(weights, expected, skipna): + + da = DataArray([np.nan, 2]) + weights = DataArray(weights) + + if skipna: + expected = DataArray(expected) + else: + expected = DataArray(np.nan) + + result = da.weighted(weights).mean(skipna=skipna) + + assert_equal(expected, result) + + +def expected_weighted(da, weights, dim, skipna, operation): + """ + Generate expected result using ```` and ``sum``. This is checked against + the result of da.weighted which uses ``dot`` + """ + + weighted_sum = (da weights).sum(dim=dim, skipna=skipna) + + if operation == "sum": + return weighted_sum + + masked_weights = weights.where(da.notnull()) + sum_of_weights = masked_weights.sum(dim=dim, skipna=True) + valid_weights = sum_of_weights != 0 + sum_of_weights = sum_of_weights.where(valid_weights) + + if operation == "sum_of_weights": + return sum_of_weights + + weighted_mean = weighted_sum / sum_of_weights + + if operation == "mean": + return weighted_mean + + +@pytest.mark.parametrize("dim", ("a", "b", "c", ("a", "b"), ("a", "b", "c"), None)) +@pytest.mark.parametrize("operation", ("sum_of_weights", "sum", "mean")) +@pytest.mark.parametrize("add_nans", (True, False)) +@pytest.mark.parametrize("skipna", (None, True, False)) +@pytest.mark.parametrize("as_dataset", (True, False)) +def test_weighted_operations_3D(dim, operation, add_nans, skipna, as_dataset): + + dims = ("a", "b", "c") + coords = dict(a=[0, 1, 2, 3], b=[0, 1, 2, 3], c=[0, 1, 2, 3]) + + weights = DataArray(np.random.randn(4, 4, 4), dims=dims, coords=coords) + + data = np.random.randn(4, 4, 4) + + # add approximately 25 % NaNs (https://stackoverflow.com/a/32182680/3010700) + if add_nans: + c = int(data.size * 0.25) + data.ravel()[np.random.choice(data.size, c, replace=False)] = np.NaN + + data = DataArray(data, dims=dims, coords=coords) + + if as_dataset: + data = data.to_dataset(name="data") + + if operation == "sum_of_weights": + result = data.weighted(weights).sum_of_weights(dim) + else: + result = getattr(data.weighted(weights), operation)(dim, skipna=skipna) + + expected = expected_weighted(data, weights, dim, skipna, operation) + + assert_allclose(expected, result) + + +@pytest.mark.parametrize("operation", ("sum_of_weights", "sum", "mean")) +@pytest.mark.parametrize("as_dataset", (True, False)) +def test_weighted_operations_nonequal_coords(operation, as_dataset): + + weights = DataArray(np.random.randn(4), dims=("a",), coords=dict(a=[0, 1, 2, 3])) + data = DataArray(np.random.randn(4), dims=("a",), coords=dict(a=[1, 2, 3, 4])) + + if as_dataset: + data = data.to_dataset(name="data") + + expected = expected_weighted( + data, weights, dim="a", skipna=None, operation=operation + ) + result = getattr(data.weighted(weights), operation)(dim="a") + + assert_allclose(expected, result) + + +@pytest.mark.parametrize("dim", ("dim_0", None)) +@pytest.mark.parametrize("shape_data", ((4,), (4, 4), (4, 4, 4))) +@pytest.mark.parametrize("shape_weights", ((4,), (4, 4), (4, 4, 4))) +@pytest.mark.parametrize("operation", ("sum_of_weights", "sum", "mean")) +@pytest.mark.parametrize("add_nans", (True, False)) +@pytest.mark.parametrize("skipna", (None, True, False)) +@pytest.mark.parametrize("as_dataset", (True, False)) +def test_weighted_operations_different_shapes( + dim, shape_data, shape_weights, operation, add_nans, skipna, as_dataset +): + + weights = DataArray(np.random.randn(shape_weights)) + + data = np.random.randn(shape_data) + + # add approximately 25 % NaNs + if add_nans: + c = int(data.size * 0.25) + data.ravel()[np.random.choice(data.size, c, replace=False)] = np.NaN + + data = DataArray(data) + + if as_dataset: + data = data.to_dataset(name="data") + + if operation == "sum_of_weights": + result = getattr(data.weighted(weights), operation)(dim) + else: + result = getattr(data.weighted(weights), operation)(dim, skipna=skipna) + + expected = expected_weighted(data, weights, dim, skipna, operation) + + assert_allclose(expected, result) + + +@pytest.mark.parametrize("operation", ("sum_of_weights", "sum", "mean")) +@pytest.mark.parametrize("as_dataset", (True, False)) +@pytest.mark.parametrize("keep_attrs", (True, False, None)) +def test_weighted_operations_keep_attr(operation, as_dataset, keep_attrs): + + weights = DataArray(np.random.randn(2, 2), attrs=dict(attr="weights")) + data = DataArray(np.random.randn(2, 2)) + + if as_dataset: + data = data.to_dataset(name="data") + + data.attrs = dict(attr="weights") + + result = getattr(data.weighted(weights), operation)(keep_attrs=True) + + if operation == "sum_of_weights": + assert weights.attrs == result.attrs + else: + assert data.attrs == result.attrs + + result = getattr(data.weighted(weights), operation)(keep_attrs=None) + assert not result.attrs + + result = getattr(data.weighted(weights), operation)(keep_attrs=False) + assert not result.attrs + + +@pytest.mark.xfail(reason="xr.Dataset.map does not copy attrs of DataArrays GH: 3595") +@pytest.mark.parametrize("operation", ("sum", "mean")) +def test_weighted_operations_keep_attr_da_in_ds(operation): + # GH #3595 + + weights = DataArray(np.random.randn(2, 2)) + data = DataArray(np.random.randn(2, 2), attrs=dict(attr="data")) + data = data.to_dataset(name="a") + + result = getattr(data.weighted(weights), operation)(keep_attrs=True) + + assert data.a.attrs == result.a.attrs	diff --git a/doc/api.rst b/doc/api.rst index 4492d882355..43a9cf53ead 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -165,6 +165,7 @@ Computation Dataset.groupby_bins Dataset.rolling Dataset.rolling_exp + Dataset.weighted Dataset.coarsen Dataset.resample Dataset.diff @@ -340,6 +341,7 @@ Computation DataArray.groupby_bins DataArray.rolling DataArray.rolling_exp + DataArray.weighted DataArray.coarsen DataArray.dt DataArray.resample @@ -577,6 +579,22 @@ Rolling objects core.rolling.DatasetRolling.reduce core.rolling_exp.RollingExp +Weighted objects +================ + +.. autosummary:: + :toctree: generated/ + + core.weighted.DataArrayWeighted + core.weighted.DataArrayWeighted.mean + core.weighted.DataArrayWeighted.sum + core.weighted.DataArrayWeighted.sum_of_weights + core.weighted.DatasetWeighted + core.weighted.DatasetWeighted.mean + core.weighted.DatasetWeighted.sum + core.weighted.DatasetWeighted.sum_of_weights + + Coarsen objects =============== diff --git a/doc/computation.rst b/doc/computation.rst index 1ac30f55ee7..5309f27e9b6 100644 --- a/doc/computation.rst +++ b/doc/computation.rst @@ -1,3 +1,5 @@ +.. currentmodule:: xarray + .. _comput: ########### @@ -241,12 +243,94 @@ You can also use ``construct`` to compute a weighted rolling sum: To avoid this, use ``skipna=False`` as the above example. +.. _comput.weighted: + +Weighted array reductions +========================= + +:py:class:`DataArray` and :py:class:`Dataset` objects include :py:meth:`DataArray.weighted` +and :py:meth:`Dataset.weighted` array reduction methods. They currently +support weighted ``sum`` and weighted ``mean``. + +.. ipython:: python + + coords = dict(month=('month', [1, 2, 3])) + + prec = xr.DataArray([1.1, 1.0, 0.9], dims=('month', ), coords=coords) + weights = xr.DataArray([31, 28, 31], dims=('month', ), coords=coords) + +Create a weighted object: + +.. ipython:: python + + weighted_prec = prec.weighted(weights) + weighted_prec + +Calculate the weighted sum: + +.. ipython:: python + + weighted_prec.sum() + +Calculate the weighted mean: + +.. ipython:: python + + weighted_prec.mean(dim="month") + +The weighted sum corresponds to: + +.. ipython:: python + + weighted_sum = (prec * weights).sum() + weighted_sum + +and the weighted mean to: + +.. ipython:: python + + weighted_mean = weighted_sum / weights.sum() + weighted_mean + +However, the functions also take missing values in the data into account: + +.. ipython:: python + + data = xr.DataArray([np.NaN, 2, 4]) + weights = xr.DataArray([8, 1, 1]) + + data.weighted(weights).mean() + +Using ``(data * weights).sum() / weights.sum()`` would (incorrectly) result +in 0.6. + + +If the weights add up to to 0, ``sum`` returns 0: + +.. ipython:: python + + data = xr.DataArray([1.0, 1.0]) + weights = xr.DataArray([-1.0, 1.0]) + + data.weighted(weights).sum() + +and ``mean`` returns ``NaN``: + +.. ipython:: python + + data.weighted(weights).mean() + + +.. note:: + ``weights`` must be a :py:class:`DataArray` and cannot contain missing values. + Missing values can be replaced manually by ``weights.fillna(0)``. + .. _comput.coarsen: Coarsen large arrays ==================== -``DataArray`` and ``Dataset`` objects include a +:py:class:`DataArray` and :py:class:`Dataset` objects include a :py:meth:`~xarray.DataArray.coarsen` and :py:meth:`~xarray.Dataset.coarsen` methods. This supports the block aggregation along multiple dimensions, diff --git a/doc/examples.rst b/doc/examples.rst index 805395808e0..1d48d29bcc5 100644 --- a/doc/examples.rst +++ b/doc/examples.rst @@ -6,6 +6,7 @@ Examples examples/weather-data examples/monthly-means + examples/area_weighted_temperature examples/multidimensional-coords examples/visualization_gallery examples/ROMS_ocean_model diff --git a/doc/examples/area_weighted_temperature.ipynb b/doc/examples/area_weighted_temperature.ipynb new file mode 100644 index 00000000000..72876e3fc29 --- /dev/null +++ b/doc/examples/area_weighted_temperature.ipynb @@ -0,0 +1,226 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "toc": true + }, + "source": [ + "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n", + "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Compare-weighted-and-unweighted-mean-temperature\" data-toc-modified-id=\"Compare-weighted-and-unweighted-mean-temperature-1\"><span class=\"toc-item-num\">1  </span>Compare weighted and unweighted mean temperature</a></span><ul class=\"toc-item\"><li><ul class=\"toc-item\"><li><span><a href=\"#Data\" data-toc-modified-id=\"Data-1.0.1\"><span class=\"toc-item-num\">1.0.1  </span>Data</a></span></li><li><span><a href=\"#Creating-weights\" data-toc-modified-id=\"Creating-weights-1.0.2\"><span class=\"toc-item-num\">1.0.2  </span>Creating weights</a></span></li><li><span><a href=\"#Weighted-mean\" data-toc-modified-id=\"Weighted-mean-1.0.3\"><span class=\"toc-item-num\">1.0.3  </span>Weighted mean</a></span></li><li><span><a href=\"#Plot:-comparison-with-unweighted-mean\" data-toc-modified-id=\"Plot:-comparison-with-unweighted-mean-1.0.4\"><span class=\"toc-item-num\">1.0.4  </span>Plot: comparison with unweighted mean</a></span></li></ul></li></ul></li></ul></div>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Compare weighted and unweighted mean temperature\n", + "\n", + "\n", + "Author: [Mathias Hauser](https://github.com/mathause/)\n", + "\n", + "\n", + "We use the `air_temperature` example dataset to calculate the area-weighted temperature over its domain. This dataset has a regular latitude/ longitude grid, thus the gridcell area decreases towards the pole. For this grid we can use the cosine of the latitude as proxy for the grid cell area.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:43:57.222351Z", + "start_time": "2020-03-17T14:43:56.147541Z" + } + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import cartopy.crs as ccrs\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "import xarray as xr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data\n", + "\n", + "Load the data, convert to celsius, and resample to daily values" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:43:57.831734Z", + "start_time": "2020-03-17T14:43:57.651845Z" + } + }, + "outputs": [], + "source": [ + "ds = xr.tutorial.load_dataset(\"air_temperature\")\n", + "\n", + "# to celsius\n", + "air = ds.air - 273.15\n", + "\n", + "# resample from 6-hourly to daily values\n", + "air = air.resample(time=\"D\").mean()\n", + "\n", + "air" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the first timestep:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:43:59.887120Z", + "start_time": "2020-03-17T14:43:59.582894Z" + } + }, + "outputs": [], + "source": [ + "projection = ccrs.LambertConformal(central_longitude=-95, central_latitude=45)\n", + "\n", + "f, ax = plt.subplots(subplot_kw=dict(projection=projection))\n", + "\n", + "air.isel(time=0).plot(transform=ccrs.PlateCarree(), cbar_kwargs=dict(shrink=0.7))\n", + "ax.coastlines()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creating weights\n", + "\n", + "For a for a rectangular grid the cosine of the latitude is proportional to the grid cell area." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:44:18.777092Z", + "start_time": "2020-03-17T14:44:18.736587Z" + } + }, + "outputs": [], + "source": [ + "weights = np.cos(np.deg2rad(air.lat))\n", + "weights.name = \"weights\"\n", + "weights" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Weighted mean" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:44:52.607120Z", + "start_time": "2020-03-17T14:44:52.564674Z" + } + }, + "outputs": [], + "source": [ + "air_weighted = air.weighted(weights)\n", + "air_weighted" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:44:54.334279Z", + "start_time": "2020-03-17T14:44:54.280022Z" + } + }, + "outputs": [], + "source": [ + "weighted_mean = air_weighted.mean((\"lon\", \"lat\"))\n", + "weighted_mean" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot: comparison with unweighted mean\n", + "\n", + "Note how the weighted mean temperature is higher than the unweighted." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:45:08.877307Z", + "start_time": "2020-03-17T14:45:08.673383Z" + } + }, + "outputs": [], + "source": [ + "weighted_mean.plot(label=\"weighted\")\n", + "air.mean((\"lon\", \"lat\")).plot(label=\"unweighted\")\n", + "\n", + "plt.legend()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.6" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": true, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/whats-new.rst b/doc/whats-new.rst index aad0e083a8c..5640e872bea 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -25,6 +25,9 @@ Breaking changes New Features ~~~~~~~~~~~~ +- Weighted array reductions are now supported via the new :py:meth:`DataArray.weighted` + and :py:meth:`Dataset.weighted` methods. See :ref:`comput.weighted`. (:issue:`422`, :pull:`2922`). + By `Mathias Hauser <https://github.com/mathause>`_ - Added support for :py:class:`pandas.DatetimeIndex`-style rounding of ``cftime.datetime`` objects directly via a :py:class:`CFTimeIndex` or via the :py:class:`~core.accessor_dt.DatetimeAccessor`.	[ { "components": [ { "doc": "Weighted operations.\n\nParameters\n----------\nweights : DataArray\n An array of weights associated with the values in this Dataset.\n Each value in the data contributes to the reduction operation\n according to its associated weight.\n\nNotes\n-----\n``weight...	[ "xarray/tests/test_weighted.py::test_weighted_non_DataArray_weights[True]", "xarray/tests/test_weighted.py::test_weighted_non_DataArray_weights[False]", "xarray/tests/test_weighted.py::test_weighted_weights_nan_raises[weights0-True]", "xarray/tests/test_weighted.py::test_weighted_weights_nan_raises[weights0-F...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feature/weighted - [X] Closes #422 - [X] Tests added - [X] Fully documented, including `whats-new.rst` for all changes and `api.rst` for new API I took a shot at the weighted function - I added a `DataArrayWeighted` class, that currently only implements `mean`. So, there is still quite a bit missing (e.g. `DatasetWeighted`), but let me know what you think. ``` python import numpy as np import xarray as xr da = xr.DataArray([1, 2]) weights = xr.DataArray([4, 6]) da.weighted(weights).mean() # <xarray.DataArray ()> # array(1.6) ``` There are quite a number of difficult edge cases with invalid data, that can be discussed. * I decided to replace all `NaN` in the `weights` with `0`. * if weights sum to `0` it returns `NaN` (and not `inf`) ``` python weights = xr.DataArray([0, 0]) da.weighted(weights).mean() ``` * The following returns `NaN` (could be `1`) ``` python da = xr.DataArray([1, np.nan]) weights = xr.DataArray([1, 0]) da.weighted(weights).mean(skipna=False) ``` It could be good to add all edge-case logic to a separate function but I am not sure if this is possible... ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in xarray/core/common.py] (definition of DataWithCoords.weighted:) def weighted(self, weights): """Weighted operations. Parameters ---------- weights : DataArray An array of weights associated with the values in this Dataset. Each value in the data contributes to the reduction operation according to its associated weight. Notes ----- ``weights`` must be a DataArray and cannot contain missing values. Missing values can be replaced by ``weights.fillna(0)``.""" [end of new definitions in xarray/core/common.py] [start of new definitions in xarray/core/weighted.py] (definition of Weighted:) class Weighted: """An object that implements weighted operations. You should create a Weighted object by using the ``DataArray.weighted`` or ``Dataset.weighted`` methods. See Also -------- Dataset.weighted DataArray.weighted""" (definition of Weighted.__init__:) def __init__(self, obj: "DataArray", weights: "DataArray") -> None: (definition of Weighted.__init__:) def __init__(self, obj: "Dataset", weights: "DataArray") -> None: (definition of Weighted.__init__:) def __init__(self, obj, weights): """Create a Weighted object Parameters ---------- obj : DataArray or Dataset Object over which the weighted reduction operation is applied. weights : DataArray An array of weights associated with the values in the obj. Each value in the obj contributes to the reduction operation according to its associated weight. Notes ----- ``weights`` must be a ``DataArray`` and cannot contain missing values. Missing values can be replaced by ``weights.fillna(0)``.""" (definition of Weighted._reduce:) def _reduce( da: "DataArray", weights: "DataArray", dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, skipna: Optional[bool] = None, ) -> "DataArray": """reduce using dot; equivalent to (da * weights).sum(dim, skipna) for internal use only""" (definition of Weighted._sum_of_weights:) def _sum_of_weights( self, da: "DataArray", dim: Optional[Union[Hashable, Iterable[Hashable]]] = None ) -> "DataArray": """Calculate the sum of weights, accounting for missing values """ (definition of Weighted._weighted_sum:) def _weighted_sum( self, da: "DataArray", dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, skipna: Optional[bool] = None, ) -> "DataArray": """Reduce a DataArray by a by a weighted ``sum`` along some dimension(s).""" (definition of Weighted._weighted_mean:) def _weighted_mean( self, da: "DataArray", dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, skipna: Optional[bool] = None, ) -> "DataArray": """Reduce a DataArray by a weighted ``mean`` along some dimension(s).""" (definition of Weighted._implementation:) def _implementation(self, func, dim, kwargs): (definition of Weighted.sum_of_weights:) def sum_of_weights( self, dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, keep_attrs: Optional[bool] = None, ) -> Union["DataArray", "Dataset"]: (definition of Weighted.sum:) def sum( self, dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, skipna: Optional[bool] = None, keep_attrs: Optional[bool] = None, ) -> Union["DataArray", "Dataset"]: (definition of Weighted.mean:) def mean( self, dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, skipna: Optional[bool] = None, keep_attrs: Optional[bool] = None, ) -> Union["DataArray", "Dataset"]: (definition of Weighted.__repr__:) def __repr__(self): """provide a nice str repr of our Weighted object""" (definition of DataArrayWeighted:) class DataArrayWeighted(Weighted): (definition of DataArrayWeighted._implementation:) def _implementation(self, func, dim, kwargs): (definition of DatasetWeighted:) class DatasetWeighted(Weighted): (definition of DatasetWeighted._implementation:) def _implementation(self, func, dim, **kwargs) -> "Dataset": (definition of _inject_docstring:) def _inject_docstring(cls, cls_name): [end of new definitions in xarray/core/weighted.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> add average function It would be nice to be able to do `ds.average()` to compute weighted averages (e.g. for geo data). Of course this would require the axes to be in a predictable order. Or to give a weight per dimension... ---------- Module error checking, etc., this would look something like: ``` python def average(self, dim=None, weights=None): if weights is None: return self.mean(dim) else: return (self * weights).sum(dim) / weights.sum(dim) ``` This is pretty easy to do manually, but I can see the value in having the standard method around, so I'm definitely open to PRs to add this functionality. This is has to be adjusted if there are `NaN` in the array. `weights.sum(dim)` needs to be corrected not to count weights on indices where there is a `NaN` in `self`. Is there a better way to get the correct weights than: ``` total_weights = weights.sum(dim) * self / self ``` It should probably not be used on a Dataset as every DataArray may have its own `NaN` structure. Or the equivalent Dataset method should loop through the DataArrays. Possibly using where, e.g., `weights.where(self.notnull()).sum(dim)`. Thanks - that seems to be the fastest possibility. I wrote the functions for Dataset and DataArray ``` python def average_da(self, dim=None, weights=None): """ weighted average for DataArrays Parameters ---------- dim : str or sequence of str, optional Dimension(s) over which to apply average. weights : DataArray weights to apply. Shape must be broadcastable to shape of self. Returns ------- reduced : DataArray New DataArray with average applied to its data and the indicated dimension(s) removed. """ if weights is None: return self.mean(dim) else: if not isinstance(weights, xray.DataArray): raise ValueError("weights must be a DataArray") # if NaNs are present, we need individual weights if self.notnull().any(): total_weights = weights.where(self.notnull()).sum(dim=dim) else: total_weights = weights.sum(dim) return (self * weights).sum(dim) / total_weights # ----------------------------------------------------------------------------- def average_ds(self, dim=None, weights=None): """ weighted average for Datasets Parameters ---------- dim : str or sequence of str, optional Dimension(s) over which to apply average. weights : DataArray weights to apply. Shape must be broadcastable to shape of data. Returns ------- reduced : Dataset New Dataset with average applied to its data and the indicated dimension(s) removed. """ if weights is None: return self.mean(dim) else: return self.apply(average_da, dim=dim, weights=weights) ``` They can be combined to one function: ``` python def average(data, dim=None, weights=None): """ weighted average for xray objects Parameters ---------- data : Dataset or DataArray the xray object to average over dim : str or sequence of str, optional Dimension(s) over which to apply average. weights : DataArray weights to apply. Shape must be broadcastable to shape of data. Returns ------- reduced : Dataset or DataArray New xray object with average applied to its data and the indicated dimension(s) removed. """ if isinstance(data, xray.Dataset): return average_ds(data, dim, weights) elif isinstance(data, xray.DataArray): return average_da(data, dim, weights) else: raise ValueError("date must be an xray Dataset or DataArray") ``` Or a monkey patch: ``` python xray.DataArray.average = average_da xray.Dataset.average = average_ds ``` @MaximilianR has suggested a `groupby`/`rolling`-like interface to weighted reductions. ``` Python da.weighted(weights=ds.dim).mean() # or maybe da.weighted(time=days_per_month(da.time)).mean() ``` I really like this idea, as does @shoyer. I'm going to close my PR in hopes of this becoming reality. I would suggest not using keyword arguments for `weighted`. Instead, just align based on the labels of the argument like regular xarray operations. So we'd write `da.weighted(days_per_month(da.time)).mean()` Sounds like a clean solution. Then we can defer handling of NaN in the weights to `weighted` (e.g. by a `skipna_weights` argument in `weighted`). Also returning `sum_of_weights` can be a method of the class. We may still end up implementing all required methods separately in `weighted`. For mean we do: ``` (data * weights / sum_of_weights).sum(dim=dim) ``` i.e. we use `sum` and not `mean`. We could rewrite this to: ``` (data * weights / sum_of_weights).mean(dim=dim) * weights.count(dim=dim) ``` However, I think this can not be generalized to a `reduce` function. See e.g. for `std` http://stackoverflow.com/questions/30383270/how-do-i-calculate-the-standard-deviation-between-weighted-measurements Additionally, `weighted` does not make sense for many operations (I would say) e.g.: `min`, `max`, `count`, ... Do we want ``` da.weighted(weight, dim='time').mean() ``` or ``` da.weighted(weight).mean(dim='time') ``` @mathause - I would think you want the latter (`da.weighted(weight).mean(dim='time')`). `weighted` should handle the brodcasting of `weight` such that you could do this: ``` Python >>> da.shape (72, 10, 15) >>> da.dims ('time', 'x', 'y') >>> weights = some_func_of_time(time) >>> da.weighted(weights).mean(dim=('time', 'x')) ... ``` Yes, +1 for `da.weighted(weight).mean(dim='time')`. The `mean` method on `weighted` should have the same arguments as the `mean` method on `DataArray` -- it's just changed due to the context. > We may still end up implementing all required methods separately in weighted. This is a fair point, I haven't looked in to the details of these implementations yet. But I expect there are still at least a few picks of logic that we will be able to share. @mathause can you please comment on the status of this issue? Is there an associated PR somewhere? Thanks! Hi, my research group recently discussed weighted averaging with x-array, and I was wondering if there had been any progress with implementing this? I'd be happy to get involved if help is needed. Thanks! Hi, This would be a really nice feature to have. I'd be happy to help too. Thank you Found this issue due to @rabernats [blogpost](https://medium.com/pangeo/supporting-new-xarray-contributors-6c42b12b0811). This is a much requested feature in our working group, and it would be great to build onto it in xgcm aswell. I would be very keen to help this advance. It would be great to have some progress on this issue! @mathause, @pgierz, @markelg, or @jbusecke if there is anything we can do to help you get started let us know. I have to say that I am still pretty bad at thinking fully object orientented, but is this what we want in general? A subclass `of xr.DataArray` which gets initialized with a weight array and with some logic for nans then 'knows' about the weight count? Where would I find a good analogue for this sort of organization? In the `rolling` class? I like the syntax proposed by @jhamman above, but I am wondering what happens in a slightly modified example: ``` >>> da.shape (72, 10, 15) >>> da.dims ('time', 'x', 'y') >>> weights = some_func_of_x(x) >>> da.weighted(weights).mean(dim=('x', 'y')) ``` I think we should maybe build in a warning that when the `weights` array does not contain both of the average dimensions? It was mentioned that the functions on `...weighted()`, would have to be mostly rewritten since the logic for a weigthed average and std differs. What other functions should be included (if any)? > I think we should maybe build in a warning that when the weights array does not contain both of the average dimensions? hmm.. the intent here would be that the weights are broadcasted against the input array no? Not sure that a warning is required. e.g. @shoyer's comment above: > I would suggest not using keyword arguments for `weighted`. Instead, just align based on the labels of the argument like regular xarray operations. So we'd write `da.weighted(days_per_month(da.time)).mean()` Are we going to require that the argument to `weighted` is a `DataArray` that shares at least one dimension with `da`? Point taken. I am still not thinking general enough :-) > Are we going to require that the argument to weighted is a DataArray that shares at least one dimension with da? This sounds good to me. With regard to the implementation, I thought of orienting myself along the lines of `groupby`, `rolling` or `resample`. Or are there any concerns for this specific method? Maybe a bad question, but is there a good jumping off point to gain some familiarity with the code base? It’s admittedly my first time looking at xarray from the inside... @pgierz take a look at the "good first issue" label: https://github.com/pydata/xarray/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22 @pgierz - Our documentation has a page on [contributing](http://xarray.pydata.org/en/stable/contributing.html) which I encourage you to read through. ~Unfortunately, we don't have any "developer documentation" to explain the actual code base itself. That would be good to add at some point.~ Edit: that was wrong. We have a page on [xarray internals](http://xarray.pydata.org/en/stable/internals.html). Once you have your local development environment set up and your fork cloned, the next step is to start exploring the source code and figuring out where changes need to be made. At that point, you can post any questions you have here and we will be happy to give you some guidance. Can the stats functions from https://esmlab.readthedocs.io/en/latest/api.html#statistics-functions be used? > With regard to the implementation, I thought of orienting myself along the lines of groupby, rolling or resample. Or are there any concerns for this specific method? I would do the same i.e. take inspiration from the groupby / rolling / resample modules. -------------------- </issues>	1c198a191127c601d091213c4b3292a8bb3054e1
sympy__sympy-16693	16,693	sympy/sympy	1.5	967df3b9dc4a5b98a019d18883d72ac14a5955d6	2019-04-20T07:41:44Z	diff --git a/sympy/core/basic.py b/sympy/core/basic.py index bac4d403209a..208b1be2b12a 100644 --- a/sympy/core/basic.py +++ b/sympy/core/basic.py @@ -1666,7 +1666,7 @@ def _visit_eval_derivative_array(self, base): # Types are (base: array/matrix, self: scalar) # Base is some kind of array/matrix, # it should have `.applyfunc(lambda x: x.diff(self)` implemented: - return base._eval_derivative(self) + return base._eval_derivative_array(self) def _eval_derivative_n_times(self, s, n): # This is the default evaluator for derivatives (as called by `diff` diff --git a/sympy/core/function.py b/sympy/core/function.py index 7ed066a03cb9..7497d58d6014 100644 --- a/sympy/core/function.py +++ b/sympy/core/function.py @@ -1331,7 +1331,7 @@ def __new__(cls, expr, variables, kwargs): if zero: if isinstance(expr, (MatrixCommon, NDimArray)): return expr.zeros(expr.shape) - else: + elif expr.is_scalar: return S.Zero # make the order of symbols canonical diff --git a/sympy/matrices/expressions/hadamard.py b/sympy/matrices/expressions/hadamard.py index 7cbb317e0735..cc9221739f9e 100644 --- a/sympy/matrices/expressions/hadamard.py +++ b/sympy/matrices/expressions/hadamard.py @@ -85,17 +85,17 @@ def _eval_derivative_matrix_lines(self, x): diagonal = [(0, 2), (3, 4)] diagonal = [e for j, e in enumerate(diagonal) if self.shape[j] != 1] for i in d: - ptr1 = i.first_pointer - ptr2 = i.second_pointer + l1 = i._lines[i._first_line_index] + l2 = i._lines[i._second_line_index] subexpr = ExprBuilder( CodegenArrayDiagonal, [ ExprBuilder( CodegenArrayTensorProduct, [ - ExprBuilder(_make_matrix, [i._lines[0]]), + ExprBuilder(_make_matrix, [l1]), hadam, - ExprBuilder(_make_matrix, [i._lines[1]]), + ExprBuilder(_make_matrix, [l2]), ] ), ] + diagonal, # turn into diagonal after dropping Python 2.7 @@ -176,19 +176,19 @@ def _eval_derivative_matrix_lines(self, x): lr = self.base._eval_derivative_matrix_lines(x) for i in lr: - ptr1 = i.first_pointer - ptr2 = i.second_pointer diagonal = [(1, 2), (3, 4)] diagonal = [e for j, e in enumerate(diagonal) if self.base.shape[j] != 1] + l1 = i._lines[i._first_line_index] + l2 = i._lines[i._second_line_index] subexpr = ExprBuilder( CodegenArrayDiagonal, [ ExprBuilder( CodegenArrayTensorProduct, [ - ExprBuilder(_make_matrix, [ptr1]), + ExprBuilder(_make_matrix, [l1]), self.exphadamard_power(self.base, self.exp-1), - ExprBuilder(_make_matrix, [ptr2]), + ExprBuilder(_make_matrix, [l2]), ] ), ] + diagonal, # turn into diagonal after dropping Python 2.7 @@ -196,7 +196,9 @@ def _eval_derivative_matrix_lines(self, x): ) i._first_pointer_parent = subexpr.args[0].args[0].args i._first_pointer_index = 0 + i._first_line_index = 0 i._second_pointer_parent = subexpr.args[0].args[2].args - i._second_pointer_index = 2 + i._second_pointer_index = 0 + i._second_line_index = 0 i._lines = [subexpr] return lr diff --git a/sympy/matrices/expressions/matexpr.py b/sympy/matrices/expressions/matexpr.py index 8e4da20e3fa0..0ee72798fe99 100644 --- a/sympy/matrices/expressions/matexpr.py +++ b/sympy/matrices/expressions/matexpr.py @@ -69,6 +69,7 @@ class MatrixExpr(Expr): is_commutative = False is_number = False is_symbol = False + is_scalar = False def __new__(cls, args, **kwargs): args = map(_sympify, args) @@ -197,7 +198,14 @@ def _eval_adjoint(self): return Adjoint(self) def _eval_derivative(self, x): - return _matrix_derivative(self, x) + # x is a scalar: + return ZeroMatrix(self.shape[0], self.shape[1]) + + def _eval_derivative_array(self, x): + if isinstance(x, MatrixExpr): + return _matrix_derivative(self, x) + else: + return self._eval_derivative(x) def _eval_derivative_n_times(self, x, n): return Basic._eval_derivative_n_times(self, x, n) @@ -1041,8 +1049,10 @@ def __init__(self, lines, higher=S.One): self._lines = [i for i in lines] self._first_pointer_parent = self._lines self._first_pointer_index = 0 + self._first_line_index = 0 self._second_pointer_parent = self._lines self._second_pointer_index = 1 + self._second_line_index = 1 self.higher = higher @property @@ -1074,6 +1084,7 @@ def __repr__(self): def transpose(self): self._first_pointer_parent, self._second_pointer_parent = self._second_pointer_parent, self._first_pointer_parent self._first_pointer_index, self._second_pointer_index = self._second_pointer_index, self._first_pointer_index + self._first_line_index, self._second_line_index = self._second_line_index, self._first_line_index return self @staticmethod diff --git a/sympy/tensor/array/ndim_array.py b/sympy/tensor/array/ndim_array.py index 640587c1e869..4e01c8e3e6a2 100644 --- a/sympy/tensor/array/ndim_array.py +++ b/sympy/tensor/array/ndim_array.py @@ -246,6 +246,9 @@ def _eval_derivative_n_times(self, s, n): return Basic._eval_derivative_n_times(self, s, n) def _eval_derivative(self, arg): + return self.applyfunc(lambda x: x.diff(arg)) + + def _eval_derivative_array(self, arg): from sympy import derive_by_array from sympy import Tuple from sympy.matrices.common import MatrixCommon	diff --git a/sympy/matrices/expressions/tests/test_derivatives.py b/sympy/matrices/expressions/tests/test_derivatives.py index fd7bf3987901..fe0b8e7b96f7 100644 --- a/sympy/matrices/expressions/tests/test_derivatives.py +++ b/sympy/matrices/expressions/tests/test_derivatives.py @@ -10,6 +10,7 @@ from sympy.matrices.expressions import hadamard_power k = symbols("k") +i, j = symbols("i j") X = MatrixSymbol("X", k, k) x = MatrixSymbol("x", k, 1) @@ -41,6 +42,13 @@ def _check_derivative_with_explicit_matrix(expr, x, diffexpr, dim=2): assert expr.diff(x).reshape(diffexpr.shape).tomatrix() == diffexpr +def test_matrix_derivative_by_scalar(): + assert A.diff(i) == ZeroMatrix(k, k) + assert (A(X + B)c).diff(i) == ZeroMatrix(k, 1) + assert x.diff(i) == ZeroMatrix(k, 1) + assert (x.Ty).diff(i) == ZeroMatrix(1, 1) + + def test_matrix_derivative_non_matrix_result(): # This is a 4-dimensional array: assert A.diff(A) == Derivative(A, A) @@ -378,6 +386,9 @@ def test_derivatives_of_hadamard_expressions(): expr = hadamard_power(x, 2) assert expr.diff(x).doit() == 2DiagonalizeVector(x) + expr = hadamard_power(x.T, 2) + assert expr.diff(x).doit() == 2DiagonalizeVector(x) + expr = hadamard_power(x, S.Half) assert expr.diff(x) == S.Half*DiagonalizeVector(hadamard_power(x, -S.Half))		[ { "components": [ { "doc": "", "lines": [ 204, 208 ], "name": "MatrixExpr._eval_derivative_array", "signature": "def _eval_derivative_array(self, x):", "type": "function" } ], "file": "sympy/matrices/expressions/matexpr.py" ...	[ "test_matrix_derivative_by_scalar" ]	[ "test_matrix_derivative_non_matrix_result", "test_matrix_derivative_trivial_cases", "test_matrix_derivative_with_inverse", "test_matrix_derivative_vectors_and_scalars", "test_matrix_derivatives_of_traces", "test_derivatives_of_complicated_matrix_expr", "test_mixed_deriv_mixed_expressions", "test_deriv...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> allow matrix expression to be derived by scalar …d derivatives <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * matrices * Allow matrix expressions to be derived by a scalar. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/matrices/expressions/matexpr.py] (definition of MatrixExpr._eval_derivative_array:) def _eval_derivative_array(self, x): [end of new definitions in sympy/matrices/expressions/matexpr.py] [start of new definitions in sympy/tensor/array/ndim_array.py] (definition of NDimArray._eval_derivative_array:) def _eval_derivative_array(self, arg): [end of new definitions in sympy/tensor/array/ndim_array.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-16685	16,685	sympy/sympy	1.5	d10b94aa5a5863957c63eef687cee2a9d27bf99a	2019-04-19T10:19:37Z	diff --git a/sympy/matrices/__init__.py b/sympy/matrices/__init__.py index fe3ec2b31615..9eccd3757051 100644 --- a/sympy/matrices/__init__.py +++ b/sympy/matrices/__init__.py @@ -27,4 +27,4 @@ Transpose, ZeroMatrix, OneMatrix, blockcut, block_collapse, matrix_symbols, Adjoint, hadamard_product, HadamardProduct, HadamardPower, Determinant, det, diagonalize_vector, DiagonalizeVector, DiagonalMatrix, DiagonalOf, trace, - DotProduct, kronecker_product, KroneckerProduct) + DotProduct, kronecker_product, KroneckerProduct, OneMatrix) diff --git a/sympy/matrices/expressions/hadamard.py b/sympy/matrices/expressions/hadamard.py index 7ccb98e3206a..55202675d898 100644 --- a/sympy/matrices/expressions/hadamard.py +++ b/sympy/matrices/expressions/hadamard.py @@ -1,8 +1,12 @@ from __future__ import print_function, division from sympy.core import Mul, sympify -from sympy.matrices.expressions.matexpr import MatrixExpr, ShapeError -from sympy.strategies import unpack, flatten, condition, exhaust, do_one +from sympy.matrices.expressions.matexpr import ( + MatrixExpr, ShapeError, Identity, OneMatrix, ZeroMatrix +) +from sympy.strategies import ( + unpack, flatten, condition, exhaust, do_one, rm_id, sort +) def hadamard_product(matrices): @@ -36,15 +40,23 @@ class HadamardProduct(MatrixExpr): """ Elementwise product of matrix expressions - This is a symbolic object that simply stores its argument without - evaluating it. To actually compute the product, use the function - ``hadamard_product()``. + Examples + ======== + + Hadamard product for matrix symbols: >>> from sympy.matrices import hadamard_product, HadamardProduct, MatrixSymbol >>> A = MatrixSymbol('A', 5, 5) >>> B = MatrixSymbol('B', 5, 5) >>> isinstance(hadamard_product(A, B), HadamardProduct) True + + Notes + ===== + + This is a symbolic object that simply stores its argument without + evaluating it. To actually compute the product, use the function + ``hadamard_product()`` or ``HadamardProduct.doit`` """ is_HadamardProduct = True @@ -53,6 +65,7 @@ def __new__(cls, args, *kwargs): check = kwargs.get('check', True) if check: validate(args) + return super(HadamardProduct, cls).__new__(cls, args) @property @@ -119,11 +132,141 @@ def validate(args): if A.shape != B.shape: raise ShapeError("Matrices %s and %s are not aligned" % (A, B)) -rules = (unpack, - flatten) -canonicalize = exhaust(condition(lambda x: isinstance(x, HadamardProduct), - do_one(rules))) +# TODO Implement algorithm for rewriting Hadamard product as diagonal matrix +# if matmul identy matrix is multiplied. +def canonicalize(x): + """Canonicalize the Hadamard product ``x`` with mathematical properties. + + Examples + ======== + + >>> from sympy.matrices.expressions import MatrixSymbol, HadamardProduct + >>> from sympy.matrices.expressions import OneMatrix, ZeroMatrix + >>> from sympy.matrices.expressions.hadamard import canonicalize + + >>> A = MatrixSymbol('A', 2, 2) + >>> B = MatrixSymbol('B', 2, 2) + >>> C = MatrixSymbol('C', 2, 2) + + Hadamard product associativity: + + >>> X = HadamardProduct(A, HadamardProduct(B, C)) + >>> X + A.(B.C) + >>> canonicalize(X) + A.B.C + + Hadamard product commutativity: + + >>> X = HadamardProduct(A, B) + >>> Y = HadamardProduct(B, A) + >>> X + A.B + >>> Y + B.A + >>> canonicalize(X) + A.B + >>> canonicalize(Y) + A.B + + Hadamard product identity: + + >>> X = HadamardProduct(A, OneMatrix(2, 2)) + >>> X + A.OneMatrix(2, 2) + >>> canonicalize(X) + A + + Absorbing element of Hadamard product: + + >>> X = HadamardProduct(A, ZeroMatrix(2, 2)) + >>> X + A.0 + >>> canonicalize(X) + 0 + + Rewriting to Hadamard Power + + >>> X = HadamardProduct(A, A, A) + >>> X + A.A.A + >>> canonicalize(X) + A.3 + + Notes + ===== + + As the Hadamard product is associative, nested products can be flattened. + + The Hadamard product is commutative so that factors can be sorted for + canonical form. + + A matrix of only ones is an identity for Hadamard product, + so every matrices of only ones can be removed. + + Any zero matrix will make the whole product a zero matrix. + + Duplicate elements can be collected and rewritten as HadamardPower + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Hadamard_product_(matrices) + """ + from sympy.core.compatibility import default_sort_key + + # Associativity + rule = condition( + lambda x: isinstance(x, HadamardProduct), + flatten + ) + fun = exhaust(rule) + x = fun(x) + + # Identity + fun = condition( + lambda x: isinstance(x, HadamardProduct), + rm_id(lambda x: isinstance(x, OneMatrix)) + ) + x = fun(x) + + # Absorbing by Zero Matrix + def absorb(x): + if any(isinstance(c, ZeroMatrix) for c in x.args): + return ZeroMatrix(x.shape) + else: + return x + fun = condition( + lambda x: isinstance(x, HadamardProduct), + absorb + ) + x = fun(x) + + # Rewriting with HadamardPower + if isinstance(x, HadamardProduct): + from collections import Counter + tally = Counter(x.args) + + new_arg = [] + for base, exp in tally.items(): + if exp == 1: + new_arg.append(base) + else: + new_arg.append(HadamardPower(base, exp)) + + x = HadamardProduct(*new_arg) + + # Commutativity + fun = condition( + lambda x: isinstance(x, HadamardProduct), + sort(default_sort_key) + ) + x = fun(x) + + # Unpacking + x = unpack(x) + return x def hadamard_power(base, exp):	diff --git a/sympy/matrices/expressions/tests/test_hadamard.py b/sympy/matrices/expressions/tests/test_hadamard.py index d38e36aaa7ad..9864040fd29b 100644 --- a/sympy/matrices/expressions/tests/test_hadamard.py +++ b/sympy/matrices/expressions/tests/test_hadamard.py @@ -1,4 +1,4 @@ -from sympy import Identity +from sympy import Identity, OneMatrix, ZeroMatrix from sympy.core import symbols from sympy.utilities.pytest import raises @@ -37,12 +37,21 @@ def test_mixed_indexing(): assert (XHadamardProduct(Y, Z))[0, 0] == \ X[0, 0]Y[0, 0]Z[0, 0] + X[0, 1]Y[1, 0]*Z[1, 0] + def test_canonicalize(): X = MatrixSymbol('X', 2, 2) + Y = MatrixSymbol('Y', 2, 2) expr = HadamardProduct(X, check=False) assert isinstance(expr, HadamardProduct) expr2 = expr.doit() # unpack is called assert isinstance(expr2, MatrixSymbol) + Z = ZeroMatrix(2, 2) + U = OneMatrix(2, 2) + assert HadamardProduct(Z, X).doit() == Z + assert HadamardProduct(U, X, X, U).doit() == HadamardPower(X, 2) + assert HadamardProduct(X, U, Y).doit() == HadamardProduct(X, Y) + assert HadamardProduct(X, Z, U, Y).doit() == Z + def test_hadamard(): m, n, p = symbols('m, n, p', integer=True)		[ { "components": [ { "doc": "Canonicalize the Hadamard product ``x`` with mathematical properties.\n\nExamples\n========\n\n>>> from sympy.matrices.expressions import MatrixSymbol, HadamardProduct\n>>> from sympy.matrices.expressions import OneMatrix, ZeroMatrix\n>>> from sympy.matrices.expressions...	[ "test_canonicalize" ]	[ "test_HadamardProduct", "test_HadamardProduct_isnt_commutative", "test_mixed_indexing", "test_hadamard" ]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Canonicalization of Hadamard Product <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed With matrix of ones implemented in #16676, we may use the identity to make hadamard product more canonical. - [X] Associative (Default) - [X] Commutative - [X] Identity for Hadamard product by one matrix - [X] Absorbing to zero matrix when multiplied with zero matrix - [x] Rewriting to Hadamard power when repetitive matrices are multiplied. - [ ] (Optional) Reduce to diagonal matrix when multiplied with `IdentityMatrix` (Or any rectangular `eye`) After the decision is made for #16682 #### Other comments This is still work in progress, and I will add some tests if the design is set I also think that `HadamardProduct` can automatically unpack its argument, if given a single argument, like in SymPy's `Add`, `Mul`. As it is confusing that `HadamardProduct(A) == A` is giving `False` because it does not unpacks single arguent but `hadamard_product(A) == A` is giving `True`. And the printing is not suggestive that `HadamardProduct` is wrapped on this. Though changing this would make some tests fail, and there may be some discussion for design change? #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - matrices - Improved canonicalization for `HadamardProduct` - Deleted `rules` from `matrices.expressions.hadamard` <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/matrices/expressions/hadamard.py] (definition of canonicalize:) def canonicalize(x): """Canonicalize the Hadamard product ``x`` with mathematical properties. Examples ======== >>> from sympy.matrices.expressions import MatrixSymbol, HadamardProduct >>> from sympy.matrices.expressions import OneMatrix, ZeroMatrix >>> from sympy.matrices.expressions.hadamard import canonicalize >>> A = MatrixSymbol('A', 2, 2) >>> B = MatrixSymbol('B', 2, 2) >>> C = MatrixSymbol('C', 2, 2) Hadamard product associativity: >>> X = HadamardProduct(A, HadamardProduct(B, C)) >>> X A.(B.C) >>> canonicalize(X) A.B.C Hadamard product commutativity: >>> X = HadamardProduct(A, B) >>> Y = HadamardProduct(B, A) >>> X A.B >>> Y B.A >>> canonicalize(X) A.B >>> canonicalize(Y) A.B Hadamard product identity: >>> X = HadamardProduct(A, OneMatrix(2, 2)) >>> X A.OneMatrix(2, 2) >>> canonicalize(X) A Absorbing element of Hadamard product: >>> X = HadamardProduct(A, ZeroMatrix(2, 2)) >>> X A.0 >>> canonicalize(X) 0 Rewriting to Hadamard Power >>> X = HadamardProduct(A, A, A) >>> X A.A.A >>> canonicalize(X) A.**3 Notes ===== As the Hadamard product is associative, nested products can be flattened. The Hadamard product is commutative so that factors can be sorted for canonical form. A matrix of only ones is an identity for Hadamard product, so every matrices of only ones can be removed. Any zero matrix will make the whole product a zero matrix. Duplicate elements can be collected and rewritten as HadamardPower References ========== .. [1] https://en.wikipedia.org/wiki/Hadamard_product_(matrices)""" (definition of canonicalize.absorb:) def absorb(x): [end of new definitions in sympy/matrices/expressions/hadamard.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-16676	16,676	sympy/sympy	1.5	6da0ab837c472e933145cf37fd2ab0634ffa1aa6	2019-04-17T22:34:46Z	diff --git a/sympy/matrices/expressions/matexpr.py b/sympy/matrices/expressions/matexpr.py index b90c9cc933b7..8e4da20e3fa0 100644 --- a/sympy/matrices/expressions/matexpr.py +++ b/sympy/matrices/expressions/matexpr.py @@ -980,6 +980,45 @@ def __hash__(self): return super(GenericZeroMatrix, self).__hash__() +class OneMatrix(MatrixExpr): + """ + Matrix whose all entries are ones. + """ + def __new__(cls, m, n): + obj = super(OneMatrix, cls).__new__(cls, m, n) + return obj + + @property + def shape(self): + return self._args + + def as_explicit(self): + from sympy import ImmutableDenseMatrix + return ImmutableDenseMatrix.ones(self.shape) + + def _eval_transpose(self): + return OneMatrix(self.cols, self.rows) + + def _eval_trace(self): + return S.Oneself.rows + + def _eval_determinant(self): + condition = Eq(self.shape[0], 1) & Eq(self.shape[1], 1) + if condition == True: + return S.One + elif condition == False: + return S.Zero + else: + from sympy import Determinant + return Determinant(self) + + def conjugate(self): + return self + + def _entry(self, i, j, **kwargs): + return S.One + + def matrix_symbols(expr): return [sym for sym in expr.free_symbols if sym.is_Matrix]	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index eac4113f90c5..7d8ea35b66cf 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -2688,6 +2688,12 @@ def test_sympy__matrices__expressions__matexpr__ZeroMatrix(): from sympy.matrices.expressions.matexpr import ZeroMatrix assert _test_args(ZeroMatrix(3, 5)) + +def test_sympy__matrices__expressions__matexpr__OneMatrix(): + from sympy.matrices.expressions.matexpr import OneMatrix + assert _test_args(OneMatrix(3, 5)) + + def test_sympy__matrices__expressions__matexpr__GenericZeroMatrix(): from sympy.matrices.expressions.matexpr import GenericZeroMatrix assert _test_args(GenericZeroMatrix()) diff --git a/sympy/matrices/expressions/tests/test_determinant.py b/sympy/matrices/expressions/tests/test_determinant.py index 440bcd290418..9b0b347f92e4 100644 --- a/sympy/matrices/expressions/tests/test_determinant.py +++ b/sympy/matrices/expressions/tests/test_determinant.py @@ -4,6 +4,7 @@ Identity, MatrixExpr, MatrixSymbol, Determinant, det, ZeroMatrix, Transpose ) +from sympy.matrices.expressions.matexpr import OneMatrix from sympy.utilities.pytest import raises from sympy import refine, Q @@ -28,6 +29,9 @@ def test_det(): def test_eval_determinant(): assert det(Identity(n)) == 1 assert det(ZeroMatrix(n, n)) == 0 + assert det(OneMatrix(n, n)) == Determinant(OneMatrix(n, n)) + assert det(OneMatrix(1, 1)) == 1 + assert det(OneMatrix(2, 2)) == 0 assert det(Transpose(A)) == det(A) diff --git a/sympy/matrices/expressions/tests/test_matexpr.py b/sympy/matrices/expressions/tests/test_matexpr.py index d6e66f545f30..9fa4e1c806cd 100644 --- a/sympy/matrices/expressions/tests/test_matexpr.py +++ b/sympy/matrices/expressions/tests/test_matexpr.py @@ -9,7 +9,7 @@ MatPow, Matrix, MatrixExpr, MatrixSymbol, ShapeError, ZeroMatrix, SparseMatrix, Transpose, Adjoint) from sympy.matrices.expressions.matexpr import (MatrixElement, - GenericZeroMatrix, GenericIdentity) + GenericZeroMatrix, GenericIdentity, OneMatrix) from sympy.utilities.pytest import raises, XFAIL @@ -76,6 +76,36 @@ def test_ZeroMatrix_doit(): assert isinstance(Znn.doit().rows, Mul) +def test_OneMatrix(): + A = MatrixSymbol('A', n, m) + a = MatrixSymbol('a', n, 1) + U = OneMatrix(n, m) + + assert U.shape == (n, m) + assert isinstance(A + U, Add) + assert transpose(U) == OneMatrix(m, n) + assert U.conjugate() == U + + assert OneMatrix(n, n) 0 == Identity(n) + with raises(ShapeError): + U 0 + with raises(ShapeError): + U ** 2 + + U = OneMatrix(n, n) + assert U[1, 2] == 1 + + U = OneMatrix(2, 3) + assert U.as_explicit() == ImmutableMatrix.ones(2, 3) + + +def test_OneMatrix_doit(): + Unn = OneMatrix(Add(n, n, evaluate=False), n) + assert isinstance(Unn.rows, Add) + assert Unn.doit() == OneMatrix(2 * n, n) + assert isinstance(Unn.doit().rows, Mul) + + def test_Identity(): A = MatrixSymbol('A', n, m) i, j = symbols('i j') diff --git a/sympy/matrices/expressions/tests/test_trace.py b/sympy/matrices/expressions/tests/test_trace.py index b8d4a570868f..8682c9470ef1 100644 --- a/sympy/matrices/expressions/tests/test_trace.py +++ b/sympy/matrices/expressions/tests/test_trace.py @@ -6,6 +6,7 @@ Adjoint, Identity, FunctionMatrix, MatrixExpr, MatrixSymbol, Trace, ZeroMatrix, trace, MatPow, MatAdd, MatMul ) +from sympy.matrices.expressions.matexpr import OneMatrix from sympy.utilities.pytest import raises, XFAIL n = symbols('n', integer=True) @@ -30,6 +31,9 @@ def test_Trace(): # Some easy simplifications assert trace(Identity(5)) == 5 assert trace(ZeroMatrix(5, 5)) == 0 + assert trace(OneMatrix(1, 1)) == 1 + assert trace(OneMatrix(2, 2)) == 2 + assert trace(OneMatrix(n, n)) == n assert trace(2AB) == 2Trace(AB) assert trace(A.T) == trace(A)		[ { "components": [ { "doc": "Matrix whose all entries are ones.", "lines": [ 983, 1019 ], "name": "OneMatrix", "signature": "class OneMatrix(MatrixExpr):", "type": "class" }, { "doc": "", "lines": [ 98...	[ "test_sympy__matrices__expressions__matexpr__OneMatrix", "test_det", "test_eval_determinant", "test_shape", "test_matexpr", "test_subs", "test_ZeroMatrix", "test_ZeroMatrix_doit", "test_OneMatrix", "test_OneMatrix_doit", "test_Identity", "test_Identity_doit", "test_addition", "test_multipl...	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> added OneMatrix for matrix expressions with only ones <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * matrices * Introduction of `OneMatrix`, a matrix symbol representing matrices of only 1 entries. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/matrices/expressions/matexpr.py] (definition of OneMatrix:) class OneMatrix(MatrixExpr): """Matrix whose all entries are ones.""" (definition of OneMatrix.__new__:) def __new__(cls, m, n): (definition of OneMatrix.shape:) def shape(self): (definition of OneMatrix.as_explicit:) def as_explicit(self): (definition of OneMatrix._eval_transpose:) def _eval_transpose(self): (definition of OneMatrix._eval_trace:) def _eval_trace(self): (definition of OneMatrix._eval_determinant:) def _eval_determinant(self): (definition of OneMatrix.conjugate:) def conjugate(self): (definition of OneMatrix._entry:) def _entry(self, i, j, **kwargs): [end of new definitions in sympy/matrices/expressions/matexpr.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
conan-io__conan-4963	4,963	conan-io/conan	null	84a38590987ecb9f3011f73babc95598ea62535f	2019-04-12T10:24:34Z	diff --git a/conans/client/tools/version.py b/conans/client/tools/version.py new file mode 100644 index 00000000000..7822658781b --- /dev/null +++ b/conans/client/tools/version.py @@ -0,0 +1,50 @@ +# coding=utf-8 + +from functools import total_ordering + +from semver import SemVer + +from conans.errors import ConanException + + +@total_ordering +class Version(object): + _semver = None + loose = True # Allow incomplete version strings like '1.2' or '1-dev0' + + def __init__(self, value): + v = str(value).strip() + try: + self._semver = SemVer(v, loose=self.loose) + except ValueError: + raise ConanException("Invalid version '{}'".format(value)) + + @property + def major(self): + return str(self._semver.major) + + @property + def minor(self): + return str(self._semver.minor) + + @property + def patch(self): + return str(self._semver.patch) + + @property + def prerelease(self): + return str(".".join(map(str, self._semver.prerelease))) + + @property + def build(self): + return str(".".join(map(str, self._semver.build))) + + def __eq__(self, other): + if not isinstance(other, Version): + other = Version(other) + return self._semver.compare(other._semver) == 0 + + def __lt__(self, other): + if not isinstance(other, Version): + other = Version(other) + return self._semver.compare(other._semver) < 0 diff --git a/conans/tools.py b/conans/tools.py index 2f28a95f128..ee26518eaf0 100644 --- a/conans/tools.py +++ b/conans/tools.py @@ -26,6 +26,7 @@ rmdir, save as files_save, save_append, sha1sum, sha256sum, touch, sha1sum, sha256sum, \ to_file_bytes, touch from conans.util.log import logger +from conans.client.tools.version import Version # This global variables are intended to store the configuration of the running Conan application	diff --git a/conans/test/unittests/client/tools/test_version.py b/conans/test/unittests/client/tools/test_version.py new file mode 100644 index 00000000000..46ca9a3983a --- /dev/null +++ b/conans/test/unittests/client/tools/test_version.py @@ -0,0 +1,111 @@ +# coding=utf-8 + + +import unittest + +import six + +from conans.client.tools.version import Version +from conans.errors import ConanException + + +class ToolVersionMainComponentsTests(unittest.TestCase): + + def test_invalid_values(self): + self.assertRaises(ConanException, Version, "") + self.assertRaises(ConanException, Version, "nonsense") + self.assertRaises(ConanException, Version, "a1.2.3") + + def test_invalid_message(self): + with six.assertRaisesRegex(self, ConanException, "Invalid version 'not-valid'"): + Version("not-valid") + + def test_valid_values(self): + for v_str in ["1.2.3", "1.2.3-dev90", "1.2.3+dev90", "1.2.3-dev90+more", "1.2.3-dev90+a.b"]: + v = Version(v_str) + self.assertEqual(v.major, "1") + self.assertEqual(v.minor, "2") + self.assertEqual(v.patch, "3") + + def test_valid_loose(self): + self.assertTrue(Version.loose) + + # These versions are considered valid with loose validation + self.assertTrue(Version.loose) + v = Version("1.2") + self.assertEqual(v.major, "1") + self.assertEqual(v.minor, "2") + self.assertEqual(v.patch, "0") + + v = Version("1") + self.assertEqual(v.major, "1") + self.assertEqual(v.minor, "0") + self.assertEqual(v.patch, "0") + + v = Version(" 1a") + self.assertEqual(v.major, "1") + self.assertEqual(v.minor, "0") + self.assertEqual(v.patch, "0") + + def test_convert_str(self): + # Check that we are calling the string method + class A(object): + def __str__(self): + return "1.2.3" + + v = Version(A()) + self.assertEqual(v.major, "1") + self.assertEqual(v.minor, "2") + self.assertEqual(v.patch, "3") + + def test_compare(self): + self.assertTrue(Version("1.2.3") == "1.2.3") + self.assertTrue(Version("1.2.3") == Version("1.2.3")) + + self.assertTrue(Version.loose) + self.assertTrue(Version("234") == "234") + self.assertTrue(Version("234") == Version("234")) + + def test_gt(self): + self.assertTrue(Version("1.2.3") > "1.2.2") + + self.assertTrue(Version.loose) + self.assertTrue(Version("1.2") > "1") + self.assertTrue(Version("1.2") > Version("1")) + + self.assertFalse(Version("1.0") > "1") + self.assertFalse(Version("1.0.0") > "1") + self.assertFalse(Version("1") > "1.0") + self.assertFalse(Version("1") > "1.0.0") + + +class ToolVersionExtraComponentsTests(unittest.TestCase): + + def test_parsing(self): + v = Version("1.2.3-dev.90.80-dev2+build.b1.b2") + self.assertEqual(v.prerelease, "dev.90.80-dev2") + self.assertEqual(v.build, "build.b1.b2") + + v = Version("1.2.305-dev4") + self.assertEqual(v.prerelease, "dev4") + self.assertEqual(v.build, "") + + v = Version("1.2.305+dev4") + self.assertEqual(v.prerelease, "") + self.assertEqual(v.build, "dev4") + + def test_compare(self): + # prerelease is taken into account + self.assertTrue(Version("1.2.3-dev90") != "1.2.3") + self.assertTrue(Version("1.2.3-dev90") < "1.2.3") + self.assertTrue(Version("1.2.3-dev90") < Version("1.2.3")) + + # build is not taken into account + self.assertTrue(Version("1.2") == Version("1.2+dev0")) + self.assertFalse(Version("1.2") > Version("1.2+dev0")) + self.assertFalse(Version("1.2") < Version("1.2+dev0")) + + # Unknown release field, not fail (loose=True) and don't affect compare + self.assertTrue(Version.loose) + self.assertTrue(Version("1.2.3.4") == Version("1.2.3")) +		[ { "components": [ { "doc": "", "lines": [ 11, 50 ], "name": "Version", "signature": "class Version(object):", "type": "class" }, { "doc": "", "lines": [ 15, 20 ], "name": "Ve...	[ "conans/test/unittests/client/tools/test_version.py::ToolVersionMainComponentsTests::test_compare", "conans/test/unittests/client/tools/test_version.py::ToolVersionMainComponentsTests::test_convert_str", "conans/test/unittests/client/tools/test_version.py::ToolVersionMainComponentsTests::test_gt", "conans/tes...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Implement tools.Version (based on SemVer) Changelog: Feature: Create `tools.Version` with _limited_ capabilities Docs: https://github.com/conan-io/docs/pull/1253 * I'm using `loose=True` to allow incomplete versions like `1.2` (no _patch_ component) or "2" (no _minor_ nor _patch_) closes https://github.com/conan-io/conan/issues/4875 _Note.- Supersedes https://github.com/conan-io/conan/pull/4949_ ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conans/client/tools/version.py] (definition of Version:) class Version(object): (definition of Version.__init__:) def __init__(self, value): (definition of Version.major:) def major(self): (definition of Version.minor:) def minor(self): (definition of Version.patch:) def patch(self): (definition of Version.prerelease:) def prerelease(self): (definition of Version.build:) def build(self): (definition of Version.__eq__:) def __eq__(self, other): (definition of Version.__lt__:) def __lt__(self, other): [end of new definitions in conans/client/tools/version.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		4a5b19a75db9225316c8cb022a2dfb9705a2af34
scrapy__scrapy-3739	3,739	scrapy/scrapy	null	6e49c379a8ecfe92c99a37b6bb6d7e440df56bd9	2019-04-10T11:08:17Z	diff --git a/docs/topics/contracts.rst b/docs/topics/contracts.rst index 70f20d4ed36..9337375bb7c 100644 --- a/docs/topics/contracts.rst +++ b/docs/topics/contracts.rst @@ -120,3 +120,23 @@ get the failures pretty printed:: for header in self.args: if header not in response.headers: raise ContractFail('X-CustomHeader not present') + + +Detecting check runs +==================== + +When ``scrapy check`` is running, the ``SCRAPY_CHECK`` environment variable is +set to the ``true`` string. You can use `os.environ`_ to perform any change to +your spiders or your settings when ``scrapy check`` is used:: + + import os + import scrapy + + class ExampleSpider(scrapy.Spider): + name = 'example' + + def __init__(self): + if os.environ.get('SCRAPY_CHECK'): + pass # Do some scraper adjustments when a check is running + +.. _os.environ: https://docs.python.org/3/library/os.html#os.environ diff --git a/scrapy/utils/misc.py b/scrapy/utils/misc.py index ddaa7f7bf32..f638adb25a2 100644 --- a/scrapy/utils/misc.py +++ b/scrapy/utils/misc.py @@ -1,6 +1,8 @@ """Helper functions which don't fit anywhere else""" +import os import re import hashlib +from contextlib import contextmanager from importlib import import_module from pkgutil import iter_modules @@ -142,3 +144,21 @@ def create_instance(objcls, settings, crawler, args, kwargs): return objcls.from_settings(settings, args, *kwargs) else: return objcls(args, kwargs) + + +@contextmanager +def set_environ(kwargs): + """Temporarily set environment variables inside the context manager and + fully restore previous environment afterwards + """ + + original_env = {k: os.environ.get(k) for k in kwargs} + os.environ.update(kwargs) + try: + yield + finally: + for k, v in original_env.items(): + if v is None: + del os.environ[k] + else: + os.environ[k] = v	diff --git a/scrapy/commands/check.py b/scrapy/commands/check.py index b8a9ef989e7..ab73e85e7fb 100644 --- a/scrapy/commands/check.py +++ b/scrapy/commands/check.py @@ -6,7 +6,7 @@ from scrapy.commands import ScrapyCommand from scrapy.contracts import ContractsManager -from scrapy.utils.misc import load_object +from scrapy.utils.misc import load_object, set_environ from scrapy.utils.conf import build_component_list @@ -68,16 +68,17 @@ def run(self, args, opts): spider_loader = self.crawler_process.spider_loader - for spidername in args or spider_loader.list(): - spidercls = spider_loader.load(spidername) - spidercls.start_requests = lambda s: conman.from_spider(s, result) - - tested_methods = conman.tested_methods_from_spidercls(spidercls) - if opts.list: - for method in tested_methods: - contract_reqs[spidercls.name].append(method) - elif tested_methods: - self.crawler_process.crawl(spidercls) + with set_environ(SCRAPY_CHECK='true'): + for spidername in args or spider_loader.list(): + spidercls = spider_loader.load(spidername) + spidercls.start_requests = lambda s: conman.from_spider(s, result) + + tested_methods = conman.tested_methods_from_spidercls(spidercls) + if opts.list: + for method in tested_methods: + contract_reqs[spidercls.name].append(method) + elif tested_methods: + self.crawler_process.crawl(spidercls) # start checks if opts.list: diff --git a/tests/test_utils_misc/__init__.py b/tests/test_utils_misc/__init__.py index fcb7772ab43..e109d53436e 100644 --- a/tests/test_utils_misc/__init__.py +++ b/tests/test_utils_misc/__init__.py @@ -3,12 +3,13 @@ import unittest from scrapy.item import Item, Field -from scrapy.utils.misc import arg_to_iter, create_instance, load_object, walk_modules +from scrapy.utils.misc import arg_to_iter, create_instance, load_object, set_environ, walk_modules from tests import mock __doctests__ = ['scrapy.utils.misc'] + class UtilsMiscTestCase(unittest.TestCase): def test_load_object(self): @@ -130,5 +131,18 @@ def _test_with_crawler(mock, settings, crawler): with self.assertRaises(ValueError): create_instance(m, None, None) + def test_set_environ(self): + assert os.environ.get('some_test_environ') is None + with set_environ(some_test_environ='test_value'): + assert os.environ.get('some_test_environ') == 'test_value' + assert os.environ.get('some_test_environ') is None + + os.environ['some_test_environ'] = 'test' + assert os.environ.get('some_test_environ') == 'test' + with set_environ(some_test_environ='test_value'): + assert os.environ.get('some_test_environ') == 'test_value' + assert os.environ.get('some_test_environ') == 'test' + + if __name__ == "__main__": unittest.main()	diff --git a/docs/topics/contracts.rst b/docs/topics/contracts.rst index 70f20d4ed36..9337375bb7c 100644 --- a/docs/topics/contracts.rst +++ b/docs/topics/contracts.rst @@ -120,3 +120,23 @@ get the failures pretty printed:: for header in self.args: if header not in response.headers: raise ContractFail('X-CustomHeader not present') + + +Detecting check runs +==================== + +When ``scrapy check`` is running, the ``SCRAPY_CHECK`` environment variable is +set to the ``true`` string. You can use `os.environ`_ to perform any change to +your spiders or your settings when ``scrapy check`` is used:: + + import os + import scrapy + + class ExampleSpider(scrapy.Spider): + name = 'example' + + def __init__(self): + if os.environ.get('SCRAPY_CHECK'): + pass # Do some scraper adjustments when a check is running + +.. _os.environ: https://docs.python.org/3/library/os.html#os.environ	[ { "components": [ { "doc": "Temporarily set environment variables inside the context manager and\nfully restore previous environment afterwards", "lines": [ 150, 164 ], "name": "set_environ", "signature": "def set_environ(**kwargs):", "ty...	[ "tests/test_utils_misc/__init__.py::UtilsMiscTestCase::test_arg_to_iter", "tests/test_utils_misc/__init__.py::UtilsMiscTestCase::test_create_instance", "tests/test_utils_misc/__init__.py::UtilsMiscTestCase::test_load_object", "tests/test_utils_misc/__init__.py::UtilsMiscTestCase::test_set_environ", "tests/t...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG+1] Add SCRAPY_CHECK environment variable This PR implements the environment variable when running `scrapy check` as asked in #3704 . This way it is possible to have different behaviour in the scraper when running the check (like requiring less settings to be set) fixes #3704 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in scrapy/utils/misc.py] (definition of set_environ:) def set_environ(**kwargs): """Temporarily set environment variables inside the context manager and fully restore previous environment afterwards""" [end of new definitions in scrapy/utils/misc.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Set environment variable when running scrapy check Sometimes it is nice to be able to enable/disable functionality, e.g. calculating things in settings.py when just checking spider contracts instead of running a crawl. I therefor propose setting an environment variable like `SCRAPY_CHECK` when using the check command. ---------- -------------------- </issues>	57a5460529ff71c42e4d0381265b1b512b1eb09b
sympy__sympy-16576	16,576	sympy/sympy	1.5	c9330b1a062174f5d38bbbbc7afb2f47e2e72d6a	2019-04-06T17:54:46Z	diff --git a/sympy/stats/joint_rv_types.py b/sympy/stats/joint_rv_types.py index 5f3ecbdc9894..de452368a5ef 100644 --- a/sympy/stats/joint_rv_types.py +++ b/sympy/stats/joint_rv_types.py @@ -1,5 +1,6 @@ -from sympy import (sympify, S, pi, sqrt, exp, Lambda, Indexed, Gt, - IndexedBase, besselk, gamma, Interval, Range, factorial, Mul, Integer) +from sympy import (sympify, S, pi, sqrt, exp, Lambda, Indexed, Gt, IndexedBase, + besselk, gamma, Interval, Range, factorial, Mul, Integer, + Add, rf, Eq, Piecewise) from sympy.matrices import ImmutableMatrix from sympy.matrices.expressions.determinant import det from sympy.stats.joint_rv import (JointDistribution, JointPSpace, @@ -249,6 +250,150 @@ def NormalGamma(syms, mu, lamda, alpha, beta): """ return multivariate_rv(NormalGammaDistribution, syms, mu, lamda, alpha, beta) +#------------------------------------------------------------------------------- +# Multivariate Beta/Dirichlet distribution --------------------------------------------------------- + +class MultivariateBetaDistribution(JointDistribution): + + _argnames = ['alpha'] + is_Continuous = True + + def check(self, alpha): + _value_check(len(alpha) >= 2, "At least two categories should be passed.") + for a_k in alpha: + _value_check((a_k > 0) != False, "Each concentration parameter" + " should be positive.") + + @property + def set(self): + k = len(self.alpha) + return Interval(0, 1)*k + + def pdf(self, syms): + alpha = self.alpha + B = Mul.fromiter(map(gamma, alpha))/gamma(Add(alpha)) + return Mul.fromiter([sym(a_k - 1) for a_k, sym in zip(alpha, syms)])/B + +def MultivariateBeta(syms, alpha): + """ + Creates a continuous random variable with Dirichlet/Multivariate Beta + Distribution. + + The density of the dirichlet distribution can be found at [1]. + + Parameters + ========== + + alpha: positive real numbers signifying concentration numbers. + + Returns + ======= + + A RandomSymbol. + + Examples + ======== + + >>> from sympy.stats import density + >>> from sympy.stats.joint_rv import marginal_distribution + >>> from sympy.stats.joint_rv_types import MultivariateBeta + >>> from sympy import Symbol + >>> a1 = Symbol('a1', positive=True) + >>> a2 = Symbol('a2', positive=True) + >>> B = MultivariateBeta('B', [a1, a2]) + >>> C = MultivariateBeta('C', a1, a2) + >>> x = Symbol('x') + >>> y = Symbol('y') + >>> density(B)(x, y) + x*(a1 - 1)y*(a2 - 1)gamma(a1 + a2)/(gamma(a1)gamma(a2)) + >>> marginal_distribution(C, C[0])(x) + x(a1 - 1)gamma(a1 + a2)/(a2gamma(a1)gamma(a2)) + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Dirichlet_distribution + .. [2] http://mathworld.wolfram.com/DirichletDistribution.html + + """ + if not isinstance(alpha[0], list): + alpha = (list(alpha),) + return multivariate_rv(MultivariateBetaDistribution, syms, alpha[0]) + +Dirichlet = MultivariateBeta + +#------------------------------------------------------------------------------- +# Multivariate Ewens distribution --------------------------------------------------------- + +class MultivariateEwensDistribution(JointDistribution): + + _argnames = ['n', 'theta'] + is_Discrete = True + is_Continuous = False + + def check(self, n, theta): + _value_check(isinstance(n, Integer) and (n > 0) == True, + "sample size should be positive integer.") + _value_check(theta.is_positive, "mutation rate should be positive.") + + @property + def set(self): + prod_set = Range(0, self.n//1 + 1) + for i in range(2, self.n + 1): + prod_set = Range(0, self.n//i + 1) + return prod_set + + def pdf(self, syms): + n, theta = self.n, self.theta + term_1 = factorial(n)/rf(theta, n) + term_2 = Mul.fromiter([thetasyms[j]/((j+1)syms[j]factorial(syms[j])) + for j in range(n)]) + cond = Eq(sum([(k+1)syms[k] for k in range(n)]), n) + return Piecewise((term_1 * term_2, cond), (0, True)) + +def MultivariateEwens(syms, n, theta): + """ + Creates a discrete random variable with Multivariate Ewens + Distribution. + + The density of the said distribution can be found at [1]. + + Parameters + ========== + + n: postive integer of class Integer, + size of the sample or the integer whose partitions are considered + theta: mutation rate, must be positive real number. + + Returns + ======= + + A RandomSymbol. + + Examples + ======== + + >>> from sympy.stats import density + >>> from sympy.stats.joint_rv import marginal_distribution + >>> from sympy.stats.joint_rv_types import MultivariateEwens + >>> from sympy import Symbol + >>> a1 = Symbol('a1', positive=True) + >>> a2 = Symbol('a2', positive=True) + >>> ed = MultivariateEwens('E', 2, 1) + >>> density(ed)(a1, a2) + Piecewise((2*(-a2)/(factorial(a1)factorial(a2)), Eq(a1 + 2*a2, 2)), (0, True)) + >>> marginal_distribution(ed, ed[0])(a1) + Piecewise((1/factorial(a1), Eq(a1, 2)), (0, True)) + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Ewens%27s_sampling_formula + .. [2] http://www.stat.rutgers.edu/home/hcrane/Papers/STS529.pdf + + """ + return multivariate_rv(MultivariateEwensDistribution, syms, n, theta) + #------------------------------------------------------------------------------- # Multinomial distribution ---------------------------------------------------------	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index b86a8d3dd501..29d785737a6a 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1496,6 +1496,14 @@ def test_sympy__stats__joint_rv_types__NormalGammaDistribution(): from sympy.stats.joint_rv_types import NormalGammaDistribution assert _test_args(NormalGammaDistribution(1, 2, 3, 4)) +def test_sympy__stats__joint_rv_types__MultivariateBetaDistribution(): + from sympy.stats.joint_rv_types import MultivariateBetaDistribution + assert _test_args(MultivariateBetaDistribution([1, 2, 3])) + +def test_sympy__stats__joint_rv_types__MultivariateEwensDistribution(): + from sympy.stats.joint_rv_types import MultivariateEwensDistribution + assert _test_args(MultivariateEwensDistribution(5, 1)) + def test_sympy__stats__joint_rv_types__MultinomialDistribution(): from sympy.stats.joint_rv_types import MultinomialDistribution assert _test_args(MultinomialDistribution(5, [0.5, 0.1, 0.3])) diff --git a/sympy/stats/tests/test_joint_rv.py b/sympy/stats/tests/test_joint_rv.py index a9ae6e2c7b4b..63940393791b 100644 --- a/sympy/stats/tests/test_joint_rv.py +++ b/sympy/stats/tests/test_joint_rv.py @@ -1,5 +1,5 @@ -from sympy import (symbols, pi, oo, S, exp, sqrt, besselk, Indexed, factorial, - simplify, gamma) +from sympy import (symbols, pi, oo, S, exp, sqrt, besselk, Indexed, Rational, + simplify, Piecewise, factorial, Eq, gamma) from sympy.stats import density from sympy.stats.joint_rv import marginal_distribution from sympy.stats.joint_rv_types import JointRV @@ -54,6 +54,41 @@ def test_NormalGamma(): 3sqrt(10)gamma(S(7)/4)/(10sqrt(pi)gamma(S(5)/4)) assert marginal_distribution(ng, y)(1) == exp(-S(1)/4)/128 +def test_MultivariateBeta(): + from sympy.stats.joint_rv_types import MultivariateBeta + from sympy import gamma + a1, a2 = symbols('a1, a2', positive=True) + a1_f, a2_f = symbols('a1, a2', positive=False) + mb = MultivariateBeta('B', [a1, a2]) + mb_c = MultivariateBeta('C', a1, a2) + assert density(mb)(1, 2) == S(2)*(a2 - 1)gamma(a1 + a2)/\ + (gamma(a1)gamma(a2)) + assert marginal_distribution(mb_c, 0)(3) == S(3)(a1 - 1)gamma(a1 + a2)/\ + (a2gamma(a1)gamma(a2)) + raises(ValueError, lambda: MultivariateBeta('b1', [a1_f, a2])) + raises(ValueError, lambda: MultivariateBeta('b2', [a1, a2_f])) + raises(ValueError, lambda: MultivariateBeta('b3', [0, 0])) + raises(ValueError, lambda: MultivariateBeta('b4', [a1_f, a2_f])) + +def test_MultivariateEwens(): + from sympy.stats.joint_rv_types import MultivariateEwens + n, theta = symbols('n theta', positive=True) + theta_f = symbols('t_f', negative=True) + a = symbols('a_1:4', positive = True, integer = True) + ed = MultivariateEwens('E', 3, theta) + assert density(ed)(a[0], a[1], a[2]) == Piecewise((62(-a[1])3*(-a[2]) + theta*a[0]theta*a[1]theta*a[2]/ + (theta(theta + 1)(theta + 2) + factorial(a[0])factorial(a[1]) + factorial(a[2])), Eq(a[0] + 2a[1] + + 3a[2], 3)), (0, True)) + assert marginal_distribution(ed, ed[1])(a[1]) == Piecewise((62(-a[1]) + theta*a[1]/((theta + 1) + (theta + 2)factorial(a[1])), + Eq(2a[1] + 1, 3)), (0, True)) + raises(ValueError, lambda: MultivariateEwens('e1', 5, theta_f)) + raises(ValueError, lambda: MultivariateEwens('e1', n, theta)) + def test_Multinomial(): from sympy.stats.joint_rv_types import Multinomial n, x1, x2, x3, x4 = symbols('n, x1, x2, x3, x4', nonnegative=True, integer=True)		[ { "components": [ { "doc": "", "lines": [ 256, 275 ], "name": "MultivariateBetaDistribution", "signature": "class MultivariateBetaDistribution(JointDistribution):", "type": "class" }, { "doc": "", "lines": [ ...	[ "test_sympy__stats__joint_rv_types__MultivariateBetaDistribution", "test_sympy__stats__joint_rv_types__MultivariateEwensDistribution", "test_MultivariateBeta", "test_MultivariateEwens" ]	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Addition of Dirichlet, Ewens Distributions <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> [1] [GSoC Proposal](https://docs.google.com/document/d/1oIeaROiJyglpbris7X1uZPRE5ZeO0pD1ygCFhBIeATI/edit#heading=h.wb8kk2gus2ng) by @czgdp1807 [2] [GSoC Proposal](https://github.com/ritesh99rakesh/gsocProposal/blob/master/SymPy.md) by @ritesh99rakesh #### Brief description of what is fixed or changed MultivariateBetaDistribution has been added to sympy.stats.joint_rv_types. More distributions will be added after reviewing the previous one added. #### Other comments I want to use `Beta` in `sympy.stats.crv_types` for making random symbols following `MultivariateBetaDistribution` as is `Normal` being used for `MultivariateNormalDistribution`. However, the reason restricting me for using `Beta` is the difference in the way parameters are passed to the `Beta` function and `MultivariateBeta` function. The former one accepts `alpha`, `beta` as arguments and the latter one accepts, a single vector or pythonically, list, `alpha`. One solution in my mind is to use, `Beta(name, alpha)`, for both univariate and multivariate Beta distributions. The length of and type of `alpha` can be used as the deciding factor for returning either return `multivariate_rv` or `rv`. Edit - As said in [this comment](https://github.com/sympy/sympy/pull/16576#issuecomment-491218778) below, I think using `Beta` for `MultivariateBeta` or `Dirichlet` distribution is not a good idea because, most people use `Dirichlet` to denote `MultivariateBetaDistribution`, so mixing up the two distributions is not valid. However, both, `MultivariateBeta` and `Dirichlet` can be used to denote `MultivariateBetaDistributions` . #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * stats * multivariate distributions added to sympy.stats.joint_rv_types <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/joint_rv_types.py] (definition of MultivariateBetaDistribution:) class MultivariateBetaDistribution(JointDistribution): (definition of MultivariateBetaDistribution.check:) def check(self, alpha): (definition of MultivariateBetaDistribution.set:) def set(self): (definition of MultivariateBetaDistribution.pdf:) def pdf(self, syms): (definition of MultivariateBeta:) def MultivariateBeta(syms, alpha): """Creates a continuous random variable with Dirichlet/Multivariate Beta Distribution. The density of the dirichlet distribution can be found at [1]. Parameters ========== alpha: positive real numbers signifying concentration numbers. Returns ======= A RandomSymbol. Examples ======== >>> from sympy.stats import density >>> from sympy.stats.joint_rv import marginal_distribution >>> from sympy.stats.joint_rv_types import MultivariateBeta >>> from sympy import Symbol >>> a1 = Symbol('a1', positive=True) >>> a2 = Symbol('a2', positive=True) >>> B = MultivariateBeta('B', [a1, a2]) >>> C = MultivariateBeta('C', a1, a2) >>> x = Symbol('x') >>> y = Symbol('y') >>> density(B)(x, y) x*(a1 - 1)y*(a2 - 1)gamma(a1 + a2)/(gamma(a1)gamma(a2)) >>> marginal_distribution(C, C[0])(x) x(a1 - 1)gamma(a1 + a2)/(a2gamma(a1)gamma(a2)) References ========== .. [1] https://en.wikipedia.org/wiki/Dirichlet_distribution .. [2] http://mathworld.wolfram.com/DirichletDistribution.html""" (definition of MultivariateEwensDistribution:) class MultivariateEwensDistribution(JointDistribution): (definition of MultivariateEwensDistribution.check:) def check(self, n, theta): (definition of MultivariateEwensDistribution.set:) def set(self): (definition of MultivariateEwensDistribution.pdf:) def pdf(self, syms): (definition of MultivariateEwens:) def MultivariateEwens(syms, n, theta): """Creates a discrete random variable with Multivariate Ewens Distribution. The density of the said distribution can be found at [1]. Parameters ========== n: postive integer of class Integer, size of the sample or the integer whose partitions are considered theta: mutation rate, must be positive real number. Returns ======= A RandomSymbol. Examples ======== >>> from sympy.stats import density >>> from sympy.stats.joint_rv import marginal_distribution >>> from sympy.stats.joint_rv_types import MultivariateEwens >>> from sympy import Symbol >>> a1 = Symbol('a1', positive=True) >>> a2 = Symbol('a2', positive=True) >>> ed = MultivariateEwens('E', 2, 1) >>> density(ed)(a1, a2) Piecewise((2(-a2)/(factorial(a1)factorial(a2)), Eq(a1 + 2*a2, 2)), (0, True)) >>> marginal_distribution(ed, ed[0])(a1) Piecewise((1/factorial(a1), Eq(a1, 2)), (0, True)) References ========== .. [1] https://en.wikipedia.org/wiki/Ewens%27s_sampling_formula .. [2] http://www.stat.rutgers.edu/home/hcrane/Papers/STS529.pdf""" [end of new definitions in sympy/stats/joint_rv_types.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-16522	16,522	sympy/sympy	1.5	fb98dbb5a50dc13489b365ea6558e1efc5e62377	2019-03-31T17:55:05Z	diff --git a/sympy/combinatorics/fp_groups.py b/sympy/combinatorics/fp_groups.py index 8540e328057c..a3e9de25d22e 100644 --- a/sympy/combinatorics/fp_groups.py +++ b/sympy/combinatorics/fp_groups.py @@ -1,6 +1,7 @@ """Finitely Presented Groups and its algorithms. """ from __future__ import print_function, division +from sympy import S from sympy.combinatorics.free_groups import (FreeGroup, FreeGroupElement, free_group) from sympy.combinatorics.rewritingsystem import RewritingSystem @@ -360,7 +361,6 @@ def index(self, H, strategy="relator_based"): C = self.coset_enumeration(H, strategy) return len(C.table) - def __str__(self): if self.free_group.rank > 30: str_form = "<fp group with %s generators>" % self.free_group.rank @@ -383,7 +383,6 @@ def _to_perm_group(self): ''' from sympy.combinatorics import Permutation, PermutationGroup from sympy.combinatorics.homomorphisms import homomorphism - from sympy import S if self.order() == S.Infinity: raise NotImplementedError("Permutation presentation of infinite " "groups is not implemented") @@ -513,6 +512,21 @@ def elements(self): P, T = self._to_perm_group() return T.invert(P._elements) + @property + def is_cyclic(self): + """ + Return ``True`` if group is Cyclic. + + """ + if len(self.generators) <= 1: + return True + try: + P, T = self._to_perm_group() + except NotImplementedError: + raise NotImplementedError("Check for infinite Cyclic group " + "is not implemented") + return P.is_cyclic + class FpSubgroup(DefaultPrinting): ''' diff --git a/sympy/combinatorics/homomorphisms.py b/sympy/combinatorics/homomorphisms.py index de7b278b475c..b56ecbe069b4 100644 --- a/sympy/combinatorics/homomorphisms.py +++ b/sympy/combinatorics/homomorphisms.py @@ -353,7 +353,7 @@ def _image(r): # truth of equality otherwise success = codomain.make_confluent() s = codomain.equals(_image(r), identity) - if s in None and not success: + if s is None and not success: raise RuntimeError("Can't determine if the images " "define a homomorphism. Try increasing " "the maximum number of rewriting rules " diff --git a/sympy/combinatorics/perm_groups.py b/sympy/combinatorics/perm_groups.py index 7bbe2dd624a4..dba11c3b98a8 100644 --- a/sympy/combinatorics/perm_groups.py +++ b/sympy/combinatorics/perm_groups.py @@ -2,6 +2,7 @@ from random import randrange, choice from math import log +from sympy.ntheory import primefactors from sympy.combinatorics import Permutation from sympy.combinatorics.permutations import (_af_commutes_with, _af_invert, @@ -156,6 +157,7 @@ def __new__(cls, args, kwargs): obj._transitivity_degree = None obj._max_div = None obj._is_perfect = None + obj._is_cyclic = None obj._r = len(obj._generators) obj._degree = obj._generators[0].size @@ -1872,6 +1874,8 @@ def is_normal(self, gr, strict=True): d_gr = gr.degree if self.is_trivial and (d_self == d_gr or not strict): return True + if self._is_abelian: + return True new_self = self.copy() if not strict and d_self != d_gr: if d_self < d_gr: @@ -2650,6 +2654,63 @@ def order(self): self._order = m return m + def index(self, H): + """ + Returns the index of a permutation group. + + Examples + ======== + + >>> from sympy.combinatorics.permutations import Permutation + >>> from sympy.combinatorics.perm_groups import PermutationGroup + >>> a = Permutation(1,2,3) + >>> b =Permutation(3) + >>> G = PermutationGroup([a]) + >>> H = PermutationGroup([b]) + >>> G.index(H) + 3 + + """ + if H.is_subgroup(self): + return self.order()//H.order() + + @property + def is_cyclic(self): + """ + Return ``True`` if the group is Cyclic. + + Examples + ======== + + >>> from sympy.combinatorics.named_groups import AbelianGroup + >>> G = AbelianGroup(3, 4) + >>> G.is_cyclic + True + >>> G = AbelianGroup(4, 4) + >>> G.is_cyclic + False + + """ + if self._is_cyclic is not None: + return self._is_cyclic + self._is_cyclic = True + + if len(self.generators) == 1: + return True + if not self._is_abelian: + self._is_cyclic = False + return False + for p in primefactors(self.order()): + pgens = [] + for g in self.generators: + pgens.append(g*p) + if self.index(self.subgroup(pgens)) != p: + self._is_cyclic = False + return False + else: + continue + return True + def pointwise_stabilizer(self, points, incremental=True): r"""Return the pointwise stabilizer for a set of points.	diff --git a/sympy/combinatorics/tests/test_fp_groups.py b/sympy/combinatorics/tests/test_fp_groups.py index b588e229b072..36f0428922da 100644 --- a/sympy/combinatorics/tests/test_fp_groups.py +++ b/sympy/combinatorics/tests/test_fp_groups.py @@ -225,8 +225,19 @@ def test_permutation_methods(): S = FpSubgroup(G, G.derived_subgroup()) assert S.order() == 4 + def test_simplify_presentation(): # ref #16083 G = simplify_presentation(FpGroup(FreeGroup([]), [])) assert not G.generators assert not G.relators + + +def test_cyclic(): + F, x, y = free_group("x, y") + f = FpGroup(F, [xy, x-1y*-1xyx]) + assert f.is_cyclic + f = FpGroup(F, [xy, xy-1]) + assert f.is_cyclic + f = FpGroup(F, [x4, y*2, xyx-1y]) + assert not f.is_cyclic diff --git a/sympy/combinatorics/tests/test_perm_groups.py b/sympy/combinatorics/tests/test_perm_groups.py index bc6bd150b8a0..6a708c4d3cc8 100644 --- a/sympy/combinatorics/tests/test_perm_groups.py +++ b/sympy/combinatorics/tests/test_perm_groups.py @@ -938,3 +938,22 @@ def test_perfect(): assert G.is_perfect == False G = AlternatingGroup(5) assert G.is_perfect == True + + +def test_index(): + G = PermutationGroup(Permutation(0,1,2), Permutation(0,2,3)) + H = G.subgroup([Permutation(0,1,3)]) + assert G.index(H) == 4 + + +def test_cyclic(): + G = SymmetricGroup(2) + assert G.is_cyclic + G = AbelianGroup(3, 7) + assert G.is_cyclic + G = AbelianGroup(7, 7) + assert not G.is_cyclic + G = AlternatingGroup(3) + assert G.is_cyclic + G = AlternatingGroup(4) + assert not G.is_cyclic		[ { "components": [ { "doc": "Return ``True`` if group is Cyclic.", "lines": [ 516, 528 ], "name": "FpGroup.is_cyclic", "signature": "def is_cyclic(self):", "type": "function" } ], "file": "sympy/combinatorics/fp_groups.py" ...	[ "test_index" ]	[ "test_low_index_subgroups", "test_subgroup_presentations", "test_fp_subgroup", "test_permutation_methods", "test_simplify_presentation", "test_has", "test_generate", "test_order", "test_equality", "test_stabilizer", "test_center", "test_centralizer", "test_coset_rank", "test_coset_factor",...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added function to check if a group is Cyclic or not <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed Added method `is_cyclic` for both `PermutationGroup` and FpGroup. Also, added a method to compute the exponent of a PermutationGroup. #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * combinatorics * added functions is_cyclic and exponent <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/combinatorics/fp_groups.py] (definition of FpGroup.is_cyclic:) def is_cyclic(self): """Return ``True`` if group is Cyclic.""" [end of new definitions in sympy/combinatorics/fp_groups.py] [start of new definitions in sympy/combinatorics/perm_groups.py] (definition of PermutationGroup.index:) def index(self, H): """Returns the index of a permutation group. Examples ======== >>> from sympy.combinatorics.permutations import Permutation >>> from sympy.combinatorics.perm_groups import PermutationGroup >>> a = Permutation(1,2,3) >>> b =Permutation(3) >>> G = PermutationGroup([a]) >>> H = PermutationGroup([b]) >>> G.index(H) 3""" (definition of PermutationGroup.is_cyclic:) def is_cyclic(self): """Return ``True`` if the group is Cyclic. Examples ======== >>> from sympy.combinatorics.named_groups import AbelianGroup >>> G = AbelianGroup(3, 4) >>> G.is_cyclic True >>> G = AbelianGroup(4, 4) >>> G.is_cyclic False""" [end of new definitions in sympy/combinatorics/perm_groups.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
scikit-learn__scikit-learn-13549	13,549	scikit-learn/scikit-learn	0.21	66cc1c7342f7f0cc0dc57fb6d56053fc46c8e5f0	2019-03-31T16:22:16Z	diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 749fa73db7458..996952602e35c 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -691,6 +691,10 @@ Support for Python 3.4 and below has been officially dropped. :mod:`sklearn.utils` .................... +- \|Feature\| :func:`utils.resample` now accepts a ``stratify`` parameter for + sampling according to class distributions. :issue:`13549` by :user:`Nicolas + Hug <NicolasHug>`. + - \|API\| Deprecated ``warn_on_dtype`` parameter from :func:`utils.check_array` and :func:`utils.check_X_y`. Added explicit warning for dtype conversion in :func:`check_pairwise_arrays` if the ``metric`` being passed is a diff --git a/sklearn/model_selection/_split.py b/sklearn/model_selection/_split.py index de8511f9922c1..17fb16ae8340e 100644 --- a/sklearn/model_selection/_split.py +++ b/sklearn/model_selection/_split.py @@ -20,6 +20,7 @@ import numpy as np from ..utils import indexable, check_random_state, safe_indexing +from ..utils import _approximate_mode from ..utils.validation import _num_samples, column_or_1d from ..utils.validation import check_array from ..utils.multiclass import type_of_target @@ -1545,75 +1546,6 @@ def split(self, X, y=None, groups=None): return super().split(X, y, groups) -def _approximate_mode(class_counts, n_draws, rng): - """Computes approximate mode of multivariate hypergeometric. - - This is an approximation to the mode of the multivariate - hypergeometric given by class_counts and n_draws. - It shouldn't be off by more than one. - - It is the mostly likely outcome of drawing n_draws many - samples from the population given by class_counts. - - Parameters - ---------- - class_counts : ndarray of int - Population per class. - n_draws : int - Number of draws (samples to draw) from the overall population. - rng : random state - Used to break ties. - - Returns - ------- - sampled_classes : ndarray of int - Number of samples drawn from each class. - np.sum(sampled_classes) == n_draws - - Examples - -------- - >>> import numpy as np - >>> from sklearn.model_selection._split import _approximate_mode - >>> _approximate_mode(class_counts=np.array([4, 2]), n_draws=3, rng=0) - array([2, 1]) - >>> _approximate_mode(class_counts=np.array([5, 2]), n_draws=4, rng=0) - array([3, 1]) - >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]), - ... n_draws=2, rng=0) - array([0, 1, 1, 0]) - >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]), - ... n_draws=2, rng=42) - array([1, 1, 0, 0]) - """ - rng = check_random_state(rng) - # this computes a bad approximation to the mode of the - # multivariate hypergeometric given by class_counts and n_draws - continuous = n_draws * class_counts / class_counts.sum() - # floored means we don't overshoot n_samples, but probably undershoot - floored = np.floor(continuous) - # we add samples according to how much "left over" probability - # they had, until we arrive at n_samples - need_to_add = int(n_draws - floored.sum()) - if need_to_add > 0: - remainder = continuous - floored - values = np.sort(np.unique(remainder))[::-1] - # add according to remainder, but break ties - # randomly to avoid biases - for value in values: - inds, = np.where(remainder == value) - # if we need_to_add less than what's in inds - # we draw randomly from them. - # if we need to add more, we add them all and - # go to the next value - add_now = min(len(inds), need_to_add) - inds = rng.choice(inds, size=add_now, replace=False) - floored[inds] += 1 - need_to_add -= add_now - if need_to_add == 0: - break - return floored.astype(np.int) - - class StratifiedShuffleSplit(BaseShuffleSplit): """Stratified ShuffleSplit cross-validator diff --git a/sklearn/utils/__init__.py b/sklearn/utils/__init__.py index 24d62640376d7..ea56498cac7c5 100644 --- a/sklearn/utils/__init__.py +++ b/sklearn/utils/__init__.py @@ -254,6 +254,10 @@ def resample(arrays, options): generator; If None, the random number generator is the RandomState instance used by `np.random`. + stratify : array-like or None (default=None) + If not None, data is split in a stratified fashion, using this as + the class labels. + Returns ------- resampled_arrays : sequence of indexable data-structures @@ -292,14 +296,23 @@ def resample(arrays, *options): >>> resample(y, n_samples=2, random_state=0) array([0, 1]) + Example using stratification:: + + >>> y = [0, 0, 1, 1, 1, 1, 1, 1, 1] + >>> resample(y, n_samples=5, replace=False, stratify=y, + ... random_state=0) + [1, 1, 1, 0, 1] + See also -------- :func:`sklearn.utils.shuffle` """ + random_state = check_random_state(options.pop('random_state', None)) replace = options.pop('replace', True) max_n_samples = options.pop('n_samples', None) + stratify = options.pop('stratify', None) if options: raise ValueError("Unexpected kw arguments: %r" % options.keys()) @@ -318,12 +331,42 @@ def resample(arrays, *options): check_consistent_length(arrays) - if replace: - indices = random_state.randint(0, n_samples, size=(max_n_samples,)) + if stratify is None: + if replace: + indices = random_state.randint(0, n_samples, size=(max_n_samples,)) + else: + indices = np.arange(n_samples) + random_state.shuffle(indices) + indices = indices[:max_n_samples] else: - indices = np.arange(n_samples) - random_state.shuffle(indices) - indices = indices[:max_n_samples] + # Code adapted from StratifiedShuffleSplit() + y = check_array(stratify, ensure_2d=False, dtype=None) + if y.ndim == 2: + # for multi-label y, map each distinct row to a string repr + # using join because str(row) uses an ellipsis if len(row) > 1000 + y = np.array([' '.join(row.astype('str')) for row in y]) + + classes, y_indices = np.unique(y, return_inverse=True) + n_classes = classes.shape[0] + + class_counts = np.bincount(y_indices) + + # Find the sorted list of instances for each class: + # (np.unique above performs a sort, so code is O(n logn) already) + class_indices = np.split(np.argsort(y_indices, kind='mergesort'), + np.cumsum(class_counts)[:-1]) + + n_i = _approximate_mode(class_counts, max_n_samples, random_state) + + indices = [] + + for i in range(n_classes): + indices_i = random_state.choice(class_indices[i], n_i[i], + replace=replace) + indices.extend(indices_i) + + indices = random_state.permutation(indices) + # convert sparse matrices to CSR for row-based indexing arrays = [a.tocsr() if issparse(a) else a for a in arrays] @@ -694,6 +737,75 @@ def is_scalar_nan(x): return bool(isinstance(x, numbers.Real) and np.isnan(x)) +def _approximate_mode(class_counts, n_draws, rng): + """Computes approximate mode of multivariate hypergeometric. + + This is an approximation to the mode of the multivariate + hypergeometric given by class_counts and n_draws. + It shouldn't be off by more than one. + + It is the mostly likely outcome of drawing n_draws many + samples from the population given by class_counts. + + Parameters + ---------- + class_counts : ndarray of int + Population per class. + n_draws : int + Number of draws (samples to draw) from the overall population. + rng : random state + Used to break ties. + + Returns + ------- + sampled_classes : ndarray of int + Number of samples drawn from each class. + np.sum(sampled_classes) == n_draws + + Examples + -------- + >>> import numpy as np + >>> from sklearn.utils import _approximate_mode + >>> _approximate_mode(class_counts=np.array([4, 2]), n_draws=3, rng=0) + array([2, 1]) + >>> _approximate_mode(class_counts=np.array([5, 2]), n_draws=4, rng=0) + array([3, 1]) + >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]), + ... n_draws=2, rng=0) + array([0, 1, 1, 0]) + >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]), + ... n_draws=2, rng=42) + array([1, 1, 0, 0]) + """ + rng = check_random_state(rng) + # this computes a bad approximation to the mode of the + # multivariate hypergeometric given by class_counts and n_draws + continuous = n_draws * class_counts / class_counts.sum() + # floored means we don't overshoot n_samples, but probably undershoot + floored = np.floor(continuous) + # we add samples according to how much "left over" probability + # they had, until we arrive at n_samples + need_to_add = int(n_draws - floored.sum()) + if need_to_add > 0: + remainder = continuous - floored + values = np.sort(np.unique(remainder))[::-1] + # add according to remainder, but break ties + # randomly to avoid biases + for value in values: + inds, = np.where(remainder == value) + # if we need_to_add less than what's in inds + # we draw randomly from them. + # if we need to add more, we add them all and + # go to the next value + add_now = min(len(inds), need_to_add) + inds = rng.choice(inds, size=add_now, replace=False) + floored[inds] += 1 + need_to_add -= add_now + if need_to_add == 0: + break + return floored.astype(np.int) + + def check_matplotlib_support(caller_name): """Raise ImportError with detailed error message if mpl is not installed.	diff --git a/sklearn/utils/tests/test_utils.py b/sklearn/utils/tests/test_utils.py index 233d3c87efb28..f81a4830d7420 100644 --- a/sklearn/utils/tests/test_utils.py +++ b/sklearn/utils/tests/test_utils.py @@ -93,6 +93,67 @@ def test_resample(): assert_equal(len(resample([1, 2], n_samples=5)), 5) +def test_resample_stratified(): + # Make sure resample can stratify + rng = np.random.RandomState(0) + n_samples = 100 + p = .9 + X = rng.normal(size=(n_samples, 1)) + y = rng.binomial(1, p, size=n_samples) + + _, y_not_stratified = resample(X, y, n_samples=10, random_state=0, + stratify=None) + assert np.all(y_not_stratified == 1) + + _, y_stratified = resample(X, y, n_samples=10, random_state=0, stratify=y) + assert not np.all(y_stratified == 1) + assert np.sum(y_stratified) == 9 # all 1s, one 0 + + +def test_resample_stratified_replace(): + # Make sure stratified resampling supports the replace parameter + rng = np.random.RandomState(0) + n_samples = 100 + X = rng.normal(size=(n_samples, 1)) + y = rng.randint(0, 2, size=n_samples) + + X_replace, _ = resample(X, y, replace=True, n_samples=50, + random_state=rng, stratify=y) + X_no_replace, _ = resample(X, y, replace=False, n_samples=50, + random_state=rng, stratify=y) + assert np.unique(X_replace).shape[0] < 50 + assert np.unique(X_no_replace).shape[0] == 50 + + # make sure n_samples can be greater than X.shape[0] if we sample with + # replacement + X_replace, _ = resample(X, y, replace=True, n_samples=1000, + random_state=rng, stratify=y) + assert X_replace.shape[0] == 1000 + assert np.unique(X_replace).shape[0] == 100 + + +def test_resample_stratify_2dy(): + # Make sure y can be 2d when stratifying + rng = np.random.RandomState(0) + n_samples = 100 + X = rng.normal(size=(n_samples, 1)) + y = rng.randint(0, 2, size=(n_samples, 2)) + X, y = resample(X, y, n_samples=50, random_state=rng, stratify=y) + assert y.ndim == 2 + + +def test_resample_stratify_sparse_error(): + # resample must be ndarray + rng = np.random.RandomState(0) + n_samples = 100 + X = rng.normal(size=(n_samples, 2)) + y = rng.randint(0, 2, size=n_samples) + stratify = sp.csr_matrix(y) + with pytest.raises(TypeError, match='A sparse matrix was passed'): + X, y = resample(X, y, n_samples=50, random_state=rng, + stratify=stratify) + + def test_safe_mask(): random_state = check_random_state(0) X = random_state.rand(5, 4)	diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 749fa73db7458..996952602e35c 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -691,6 +691,10 @@ Support for Python 3.4 and below has been officially dropped. :mod:`sklearn.utils` .................... +- \|Feature\| :func:`utils.resample` now accepts a ``stratify`` parameter for + sampling according to class distributions. :issue:`13549` by :user:`Nicolas + Hug <NicolasHug>`. + - \|API\| Deprecated ``warn_on_dtype`` parameter from :func:`utils.check_array` and :func:`utils.check_X_y`. Added explicit warning for dtype conversion in :func:`check_pairwise_arrays` if the ``metric`` being passed is a	[ { "components": [ { "doc": "Computes approximate mode of multivariate hypergeometric.\n\nThis is an approximation to the mode of the multivariate\nhypergeometric given by class_counts and n_draws.\nIt shouldn't be off by more than one.\n\nIt is the mostly likely outcome of drawing n_draws many\nsa...	[ "sklearn/utils/tests/test_utils.py::test_resample_stratified", "sklearn/utils/tests/test_utils.py::test_resample_stratified_replace", "sklearn/utils/tests/test_utils.py::test_resample_stratify_2dy", "sklearn/utils/tests/test_utils.py::test_resample_stratify_sparse_error" ]	[ "sklearn/utils/tests/test_utils.py::test_make_rng", "sklearn/utils/tests/test_utils.py::test_deprecated", "sklearn/utils/tests/test_utils.py::test_resample", "sklearn/utils/tests/test_utils.py::test_safe_mask", "sklearn/utils/tests/test_utils.py::test_column_or_1d", "sklearn/utils/tests/test_utils.py::tes...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG] Add a stratify option to utils.resample <!-- Thanks for contributing a pull request! Please ensure you have taken a look at the contribution guidelines: https://github.com/scikit-learn/scikit-learn/blob/master/CONTRIBUTING.md#pull-request-checklist --> #### Reference Issues/PRs <!-- Example: Fixes #1234. See also #3456. Please use keywords (e.g., Fixes) to create link to the issues or pull requests you resolved, so that they will automatically be closed when your pull request is merged. See https://github.com/blog/1506-closing-issues-via-pull-requests --> Closes #13507 #### What does this implement/fix? Explain your changes. This PR adds a `stratify` option to `utils.resample`. The issue with `train_test_split` is that it will (rightfully) complain if train or testsets are empty. The code is based on that of `StratifiedShuffleSplit`. #### Any other comments? I personally need this to properly implement SuccessiveHalving #12538 <!-- Please be aware that we are a loose team of volunteers so patience is necessary; assistance handling other issues is very welcome. We value all user contributions, no matter how minor they are. If we are slow to review, either the pull request needs some benchmarking, tinkering, convincing, etc. or more likely the reviewers are simply busy. In either case, we ask for your understanding during the review process. For more information, see our FAQ on this topic: http://scikit-learn.org/dev/faq.html#why-is-my-pull-request-not-getting-any-attention. Thanks for contributing! --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/utils/__init__.py] (definition of _approximate_mode:) def _approximate_mode(class_counts, n_draws, rng): """Computes approximate mode of multivariate hypergeometric. This is an approximation to the mode of the multivariate hypergeometric given by class_counts and n_draws. It shouldn't be off by more than one. It is the mostly likely outcome of drawing n_draws many samples from the population given by class_counts. Parameters ---------- class_counts : ndarray of int Population per class. n_draws : int Number of draws (samples to draw) from the overall population. rng : random state Used to break ties. Returns ------- sampled_classes : ndarray of int Number of samples drawn from each class. np.sum(sampled_classes) == n_draws Examples -------- >>> import numpy as np >>> from sklearn.utils import _approximate_mode >>> _approximate_mode(class_counts=np.array([4, 2]), n_draws=3, rng=0) array([2, 1]) >>> _approximate_mode(class_counts=np.array([5, 2]), n_draws=4, rng=0) array([3, 1]) >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]), ... n_draws=2, rng=0) array([0, 1, 1, 0]) >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]), ... n_draws=2, rng=42) array([1, 1, 0, 0])""" [end of new definitions in sklearn/utils/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Stratified subsampler utility? I have some data `X` and `y` that I want to subsample (i.e. only keep a subset of the samples) in a stratified way. Using something like ```py _, X_sub, _, y_sub = train_test_split( X, y, stratify=stratify, train_size=None, test_size=n_samples_sub) ``` is almost what I need. But that will error if: - I happen to want exactly `X.shape[0]` samples (`ValueError: test_size=60 should be either positive and smaller than the number of samples`) - I want something close to `X.shape[0]` which is not enough to have a stratified test or train set (`ValueError: The train_size = 1 should be greater or equal to the number of classes = 2`) ---- ~~Would it make sense to add a `subsample()` util? Another option would be to add a `bypass_checks` to `train_test_split`~~ Basically what I need is a `stratify` option to `utils.resample`, that's probably the most appropriate place to introduce this. ---------- -------------------- </issues>	66cc1c7342f7f0cc0dc57fb6d56053fc46c8e5f0
sympy__sympy-16516	16,516	sympy/sympy	1.5	fb98dbb5a50dc13489b365ea6558e1efc5e62377	2019-03-31T13:46:58Z	diff --git a/doc/src/modules/crypto.rst b/doc/src/modules/crypto.rst index f7808fa8f588..2cce9f948563 100644 --- a/doc/src/modules/crypto.rst +++ b/doc/src/modules/crypto.rst @@ -50,10 +50,18 @@ substitutions at different times in the message. .. autofunction:: decipher_shift +.. autofunction:: encipher_rot13 + +.. autofunction:: decipher_rot13 + .. autofunction:: encipher_affine .. autofunction:: decipher_affine +.. autofunction:: encipher_atbash + +.. autofunction:: decipher_atbash + .. autofunction:: encipher_substitution .. autofunction:: encipher_vigenere diff --git a/sympy/crypto/__init__.py b/sympy/crypto/__init__.py index 58ffb98e59e0..0ba69df2379f 100644 --- a/sympy/crypto/__init__.py +++ b/sympy/crypto/__init__.py @@ -11,4 +11,5 @@ encipher_elgamal, dh_private_key, dh_public_key, dh_shared_key, padded_key, encipher_bifid, decipher_bifid, bifid_square, bifid5, bifid6, bifid10, decipher_gm, encipher_gm, gm_public_key, - gm_private_key, bg_private_key, bg_public_key, encipher_bg, decipher_bg) + gm_private_key, bg_private_key, bg_public_key, encipher_bg, decipher_bg, + encipher_rot13, decipher_rot13, encipher_atbash, decipher_atbash) diff --git a/sympy/crypto/crypto.py b/sympy/crypto/crypto.py index db5937ef2097..85e582c9bfee 100644 --- a/sympy/crypto/crypto.py +++ b/sympy/crypto/crypto.py @@ -259,6 +259,55 @@ def decipher_shift(msg, key, symbols=None): """ return encipher_shift(msg, -key, symbols) +def encipher_rot13(msg, symbols=None): + """ + Performs the ROT13 encryption on a given plaintext ```msg```. + + Notes + ===== + + ROT13 is a substitution cipher which substitutes each letter + in the plaintext message for the letter furthest away from it + in the English alphabet. + + Equivalently, it is just a Caeser (shift) cipher with a shift + key of 13 (midway point of the alphabet). + + See Also + ======== + + decipher_rot13 + """ + return encipher_shift(msg, 13, symbols) + +def decipher_rot13(msg, symbols=None): + """ + Performs the ROT13 decryption on a given plaintext ```msg```. + + Notes + ===== + + ```decipher_rot13``` is equivalent to ```encipher_rot13``` as both + ```decipher_shift``` with a key of 13 and ```encipher_shift``` key with a + key of 13 will return the same results. Nonetheless, + ```decipher_rot13``` has nonetheless been explicitly defined here for + consistency. + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_rot13, decipher_rot13 + >>> msg = 'GONAVYBEATARMY' + >>> ciphertext = encipher_rot13(msg);ciphertext + 'TBANILORNGNEZL' + >>> decipher_rot13(ciphertext) + 'GONAVYBEATARMY' + >>> encipher_rot13(msg) == decipher_rot13(msg) + True + >>> msg == decipher_rot13(ciphertext) + True + """ + return decipher_shift(msg, 13, symbols) ######## affine cipher examples ############ @@ -349,6 +398,53 @@ def decipher_affine(msg, key, symbols=None): """ return encipher_affine(msg, key, symbols, _inverse=True) +def encipher_atbash(msg, symbols=None): + r""" + Enciphers a given ```msg``` into its Atbash ciphertext and returns it. + + Notes + ===== + + Atbash is a substitution cipher originally used to encrypt the Hebrew + alphabet. Atbash works on the principle of mapping each alphabet to its + reverse / counterpart (i.e. a would map to z, b to y etc.) + + Atbash is functionally equivalent to the affine cipher with ```a = 25``` + and ```b = 25``` + + See Also + ======== + + decipher_atbash + """ + return encipher_affine(msg, (25,25), symbols) + +def decipher_atbash(msg, symbols=None): + r""" + Deciphers a given ```msg``` using Atbash cipher and returns it. + + Notes + ===== + + ```decipher_atbash``` is functionally equivalent to ```encipher_atbash```. + However, it has still been added as a separate function to maintain + consistency. + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_atbash, decipher_atbash + >>> msg = 'GONAVYBEATARMY' + >>> encipher_atbash(msg) + 'TLMZEBYVZGZINB' + >>> decipher_atbash(msg) + 'TLMZEBYVZGZINB' + >>> encipher_atbash(msg) == decipher_atbash(msg) + True + >>> msg == encipher_atbash(encipher_atbash(msg)) + True + """ + return decipher_affine(msg, (25,25), symbols) #################### substitution cipher ###########################	diff --git a/sympy/crypto/tests/test_crypto.py b/sympy/crypto/tests/test_crypto.py index e65f8182829a..f999cbf76fc8 100644 --- a/sympy/crypto/tests/test_crypto.py +++ b/sympy/crypto/tests/test_crypto.py @@ -14,7 +14,8 @@ dh_shared_key, decipher_shift, decipher_affine, encipher_bifid, decipher_bifid, bifid_square, padded_key, uniq, decipher_gm, encipher_gm, gm_public_key, gm_private_key, encipher_bg, decipher_bg, - bg_private_key, bg_public_key) + bg_private_key, bg_public_key, encipher_rot13, decipher_rot13, + encipher_atbash, decipher_atbash) from sympy.matrices import Matrix from sympy.ntheory import isprime, is_primitive_root from sympy.polys.domains import FF @@ -37,6 +38,12 @@ def test_encipher_shift(): assert encipher_shift("ABC", -1) == "ZAB" assert decipher_shift("ZAB", -1) == "ABC" +def test_encipher_rot13(): + assert encipher_rot13("ABC") == "NOP" + assert encipher_rot13("NOP") == "ABC" + assert decipher_rot13("ABC") == "NOP" + assert decipher_rot13("NOP") == "ABC" + def test_encipher_affine(): assert encipher_affine("ABC", (1, 0)) == "ABC" @@ -47,6 +54,11 @@ def test_encipher_affine(): assert encipher_affine("ABC", (3, 16)) == "QTW" assert decipher_affine("QTW", (3, 16)) == "ABC" +def test_encipher_atbash(): + assert encipher_atbash("ABC") == "ZYX" + assert encipher_atbash("ZYX") == "ABC" + assert decipher_atbash("ABC") == "ZYX" + assert decipher_atbash("ZYX") == "ABC" def test_encipher_substitution(): assert encipher_substitution("ABC", "BAC", "ABC") == "BAC"	diff --git a/doc/src/modules/crypto.rst b/doc/src/modules/crypto.rst index f7808fa8f588..2cce9f948563 100644 --- a/doc/src/modules/crypto.rst +++ b/doc/src/modules/crypto.rst @@ -50,10 +50,18 @@ substitutions at different times in the message. .. autofunction:: decipher_shift +.. autofunction:: encipher_rot13 + +.. autofunction:: decipher_rot13 + .. autofunction:: encipher_affine .. autofunction:: decipher_affine +.. autofunction:: encipher_atbash + +.. autofunction:: decipher_atbash + .. autofunction:: encipher_substitution .. autofunction:: encipher_vigenere	[ { "components": [ { "doc": "Performs the ROT13 encryption on a given plaintext ```msg```.\n\nNotes\n=====\n\nROT13 is a substitution cipher which substitutes each letter\nin the plaintext message for the letter furthest away from it\nin the English alphabet.\n\nEquivalently, it is just a Caeser (s...	[ "test_cycle_list", "test_encipher_shift", "test_encipher_rot13", "test_encipher_affine", "test_encipher_atbash", "test_encipher_substitution", "test_check_and_join", "test_encipher_vigenere", "test_decipher_vigenere", "test_encipher_hill", "test_decipher_hill", "test_encipher_bifid5", "test_...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added ROT13 and Atbash to sympy.crypto <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> Fixes #16495 #### Brief description of what is fixed or changed - Added ```encipher_rot13``` , ```decipher_rot13``` - Added ```encipher_atbash```, ```decipher_atbash``` - Updated tests and documentation for both. #### Other comments - Both encipher and decipher do the same thing, in theory. However I made them different functions because they are intended for different uses even though they are functionally equivalent, and would also maintain code quality and prevent ambiguity in future. #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * crypto * added ```rot13``` and ```atbash``` ciphers <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/crypto/crypto.py] (definition of encipher_rot13:) def encipher_rot13(msg, symbols=None): """Performs the ROT13 encryption on a given plaintext ```msg```. Notes ===== ROT13 is a substitution cipher which substitutes each letter in the plaintext message for the letter furthest away from it in the English alphabet. Equivalently, it is just a Caeser (shift) cipher with a shift key of 13 (midway point of the alphabet). See Also ======== decipher_rot13""" (definition of decipher_rot13:) def decipher_rot13(msg, symbols=None): """Performs the ROT13 decryption on a given plaintext ```msg```. Notes ===== ```decipher_rot13``` is equivalent to ```encipher_rot13``` as both ```decipher_shift``` with a key of 13 and ```encipher_shift``` key with a key of 13 will return the same results. Nonetheless, ```decipher_rot13``` has nonetheless been explicitly defined here for consistency. Examples ======== >>> from sympy.crypto.crypto import encipher_rot13, decipher_rot13 >>> msg = 'GONAVYBEATARMY' >>> ciphertext = encipher_rot13(msg);ciphertext 'TBANILORNGNEZL' >>> decipher_rot13(ciphertext) 'GONAVYBEATARMY' >>> encipher_rot13(msg) == decipher_rot13(msg) True >>> msg == decipher_rot13(ciphertext) True""" (definition of encipher_atbash:) def encipher_atbash(msg, symbols=None): """Enciphers a given ```msg``` into its Atbash ciphertext and returns it. Notes ===== Atbash is a substitution cipher originally used to encrypt the Hebrew alphabet. Atbash works on the principle of mapping each alphabet to its reverse / counterpart (i.e. a would map to z, b to y etc.) Atbash is functionally equivalent to the affine cipher with ```a = 25``` and ```b = 25``` See Also ======== decipher_atbash""" (definition of decipher_atbash:) def decipher_atbash(msg, symbols=None): """Deciphers a given ```msg``` using Atbash cipher and returns it. Notes ===== ```decipher_atbash``` is functionally equivalent to ```encipher_atbash```. However, it has still been added as a separate function to maintain consistency. Examples ======== >>> from sympy.crypto.crypto import encipher_atbash, decipher_atbash >>> msg = 'GONAVYBEATARMY' >>> encipher_atbash(msg) 'TLMZEBYVZGZINB' >>> decipher_atbash(msg) 'TLMZEBYVZGZINB' >>> encipher_atbash(msg) == decipher_atbash(msg) True >>> msg == encipher_atbash(encipher_atbash(msg)) True""" [end of new definitions in sympy/crypto/crypto.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Implementing classical ciphers as special cases of already existing ciphers in crypto.py The file ```/sympy/crypto/crypto.py``` contains implementations of various classical ciphers. Extending this file to include certain other classical ciphers which are derivatives of the ones already present in the file would be useful. Such implementations would be just a couple of lines code (excluding comments explaining the working) for each as most of the ```encipher_``` functions which are required already exist. Examples of possible extensions are : [ROT13](https://en.wikipedia.org/wiki/ROT13) as an extension of ```encipher_shift()``` (and ```decipher_shift()``` likewise) [Atbash](https://en.wikipedia.org/wiki/Atbash) as an extension of ```encipher_affine()``` (and ```decipher_affine()``` likewise) If possible and if this issue is relevant, I would like to be assigned this issue and work on it and extending the ```crypto.py``` file further. ---------- @asmeurer is it okay for me to start work on this and submit a PR? -------------------- </issues>	c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-16452	16,452	sympy/sympy	1.5	4cdcbd914d66733eee1de77d592bbad3d693b049	2019-03-26T19:55:39Z	diff --git a/sympy/geometry/point.py b/sympy/geometry/point.py index 7630b517cef6..6a061ec78c5b 100644 --- a/sympy/geometry/point.py +++ b/sympy/geometry/point.py @@ -152,7 +152,7 @@ def __new__(cls, args, kwargs): raise ValueError(filldedent(''' on_morph value should be 'error', 'warn' or 'ignore'.''')) - if any(i for i in coords[dim:]): + if any(coords[dim:]): raise ValueError('Nonzero coordinates cannot be removed.') if any(a.is_number and im(a) for a in coords): raise ValueError('Imaginary coordinates are not permitted.') diff --git a/sympy/matrices/__init__.py b/sympy/matrices/__init__.py index c23ac27831a8..196951ac88a2 100644 --- a/sympy/matrices/__init__.py +++ b/sympy/matrices/__init__.py @@ -15,6 +15,7 @@ Matrix = MutableMatrix = MutableDenseMatrix from .sparse import MutableSparseMatrix +from .sparsetools import banded from .immutable import ImmutableDenseMatrix, ImmutableSparseMatrix ImmutableMatrix = ImmutableDenseMatrix diff --git a/sympy/matrices/common.py b/sympy/matrices/common.py index 832115f4f54d..721173d4ec06 100644 --- a/sympy/matrices/common.py +++ b/sympy/matrices/common.py @@ -750,8 +750,9 @@ def diag(kls, args, *kwargs): [3, 0, 0], [0, 4, 5]]) - Elements within a list need not all be of the same length unless - `strict` is set to True: + When `unpack` is False, elements within a list need not all be + of the same length. Setting `strict` to True would raise a + ValueError for the following: >>> Matrix.diag([[1, 2, 3], [4, 5], [6]], unpack=False) Matrix([ @@ -779,6 +780,7 @@ def diag(kls, args, *kwargs): """ from sympy.matrices.matrices import MatrixBase from sympy.matrices.dense import Matrix + from sympy.matrices.sparse import SparseMatrix klass = kwargs.get('cls', kls) strict = kwargs.get('strict', False) # lists -> Matrices unpack = kwargs.get('unpack', True) # unpack single sequence @@ -788,49 +790,47 @@ def diag(kls, args, *kwargs): # fill a default dict with the diagonal entries diag_entries = defaultdict(int) - R = C = 0 # keep track of the biggest index seen + rmax = cmax = 0 # keep track of the biggest index seen for m in args: - if hasattr(m, 'rows') or isinstance(m, list): - # in this case, we're a matrix or list - if hasattr(m, 'rows'): - # convert to list of lists - r, c = m.shape - m = m.tolist() + if isinstance(m, list): + if strict: + # if malformed, Matrix will raise an error + _ = Matrix(m) + r, c = _.shape + m = _.tolist() else: - # make sure all list elements are lists - r = len(m) - if strict: - # let Matrix raise the error - m = Matrix(m) - c = m.cols - m = m.tolist() - else: - m = [mi if isinstance(mi, list) else [mi] - for mi in m] - c = max(map(len, m)) - # process list of lists - for i in range(len(m)): - for j, mij in enumerate(m[i]): - diag_entries[(i + R, j + C)] = mij - R += r - C += c - else: - # in this case, we're a single value - diag_entries[(R, C)] = m - R += 1 - C += 1 + m = SparseMatrix(m) + for (i, j), _ in m._smat.items(): + diag_entries[(i + rmax, j + cmax)] = _ + r, c = m.shape + m = [] # to skip process below + elif hasattr(m, 'shape'): # a Matrix + # convert to list of lists + r, c = m.shape + m = m.tolist() + else: # in this case, we're a single value + diag_entries[(rmax, cmax)] = m + rmax += 1 + cmax += 1 + continue + # process list of lists + for i in range(len(m)): + for j, _ in enumerate(m[i]): + diag_entries[(i + rmax, j + cmax)] = _ + rmax += r + cmax += c rows = kwargs.get('rows', None) cols = kwargs.get('cols', None) if rows is None: rows, cols = cols, rows if rows is None: - rows, cols = R, C + rows, cols = rmax, cmax else: cols = rows if cols is None else cols - if rows < R or cols < C: + if rows < rmax or cols < cmax: raise ValueError(filldedent(''' The constructed matrix is {} x {} but a size of {} x {} - was specified.'''.format(R, C, rows, cols))) + was specified.'''.format(rmax, cmax, rows, cols))) return klass._eval_diag(rows, cols, diag_entries) @classmethod diff --git a/sympy/matrices/sparse.py b/sympy/matrices/sparse.py index 176f7e963066..12c554906ef0 100644 --- a/sympy/matrices/sparse.py +++ b/sympy/matrices/sparse.py @@ -133,7 +133,7 @@ def __new__(cls, args, *kwargs): value = self._sympify( op(self._sympify(i), self._sympify(j))) if value: - self._smat[(i, j)] = value + self._smat[i, j] = value elif isinstance(args[2], (dict, Dict)): def update(i, j, v): # update self._smat and make sure there are @@ -193,7 +193,7 @@ def update(i, j, v): row = [row] for j, vij in enumerate(row): if vij: - self._smat[(i, j)] = self._sympify(vij) + self._smat[i, j] = self._sympify(vij) c = max(c, len(row)) self.rows = len(v) if c else 0 self.cols = c @@ -206,7 +206,7 @@ def update(i, j, v): for j in range(self.cols): value = _list[self.colsi + j] if value: - self._smat[(i, j)] = value + self._smat[i, j] = value return self def __eq__(self, other): @@ -397,11 +397,11 @@ def _eval_col_insert(self, icol, other): row, col = key if col >= icol: col += other.cols - new_smat[(row, col)] = val + new_smat[row, col] = val # add other's keys for key, val in other._smat.items(): row, col = key - new_smat[(row, col + icol)] = val + new_smat[row, col + icol] = val return self._new(self.rows, self.cols + other.cols, new_smat) def _eval_conjugate(self): @@ -422,7 +422,7 @@ def _eval_extract(self, rowsList, colsList): # keeping only the ones that are desired for rk, ck in self._smat: if rk in urow and ck in ucol: - smat[(urow.index(rk), ucol.index(ck))] = self._smat[(rk, ck)] + smat[urow.index(rk), ucol.index(ck)] = self._smat[rk, ck] rv = self._new(len(urow), len(ucol), smat) # rv is nominally correct but there might be rows/cols @@ -484,7 +484,7 @@ def _eval_matrix_mul(self, other): indices = set(col_lookup[col].keys()) & set(row_lookup[row].keys()) if indices: val = sum(row_lookup[row][k]col_lookup[col][k] for k in indices) - smat[(row, col)] = val + smat[row, col] = val return self._new(self.rows, other.cols, smat) def _eval_row_insert(self, irow, other): @@ -496,11 +496,11 @@ def _eval_row_insert(self, irow, other): row, col = key if row >= irow: row += other.rows - new_smat[(row, col)] = val + new_smat[row, col] = val # add other's keys for key, val in other._smat.items(): row, col = key - new_smat[(row + irow, col)] = val + new_smat[row + irow, col] = val return self._new(self.rows + other.rows, self.cols, new_smat) def _eval_scalar_mul(self, other): @@ -1022,9 +1022,9 @@ def __setitem__(self, key, value): if rv is not None: i, j, value = rv if value: - self._smat[(i, j)] = value + self._smat[i, j] = value elif (i, j) in self._smat: - del self._smat[(i, j)] + del self._smat[i, j] def as_mutable(self): return self.copy() @@ -1120,7 +1120,7 @@ def col_join(self, other): for j in range(B.cols): v = b[k] if v: - A._smat[(i + A.rows, j)] = v + A._smat[i + A.rows, j] = v k += 1 else: for (i, j), v in B._smat.items(): @@ -1148,7 +1148,7 @@ def col_op(self, j, f): v = self._smat.get((i, j), S.Zero) fv = f(v, i) if fv: - self._smat[(i, j)] = fv + self._smat[i, j] = fv elif v: self._smat.pop((i, j)) @@ -1328,11 +1328,11 @@ def row_join(self, other): for j in range(B.cols): v = b[k] if v: - A._smat[(i, j + A.cols)] = v + A._smat[i, j + A.cols] = v k += 1 else: for (i, j), v in B._smat.items(): - A._smat[(i, j + A.cols)] = v + A._smat[i, j + A.cols] = v A.cols += B.cols return A @@ -1363,7 +1363,7 @@ def row_op(self, i, f): v = self._smat.get((i, j), S.Zero) fv = f(v, j) if fv: - self._smat[(i, j)] = fv + self._smat[i, j] = fv elif v: self._smat.pop((i, j)) diff --git a/sympy/matrices/sparsetools.py b/sympy/matrices/sparsetools.py index 4089094bec56..fcb218b2361e 100644 --- a/sympy/matrices/sparsetools.py +++ b/sympy/matrices/sparsetools.py @@ -1,6 +1,8 @@ from __future__ import division, print_function -from sympy.core.compatibility import range +from sympy.core.compatibility import range, as_int +from sympy.utilities.iterables import is_sequence +from sympy.utilities.misc import filldedent from .sparse import SparseMatrix @@ -36,3 +38,237 @@ def _csrtodok(csr): for l, m in zip(A[indices], JA[indices]): smat[i, m] = l return SparseMatrix((shape + [smat])) + + +def banded(args, kwargs): + """Returns a SparseMatrix from the given dictionary describing + the diagonals of the matrix. The keys are positive for upper + diagonals and negative for those below the main diagonal. The + values may be: + expressions or single-argument functions, + * lists or tuples of values, + * matrices + Unless dimensions are given, the size of the returned matrix will + be large enough to contain the largest non-zero value provided. + + kwargs + ====== + + rows : rows of the resulting matrix; computed if + not given. + + cols : columns of the resulting matrix; computed if + not given. + + Examples + ======== + + >>> from sympy import banded, ones, Matrix + >>> from sympy.abc import x + + If explicit values are given in tuples, + the matrix will autosize to contain all values, otherwise + a single value is filled onto the entire diagonal: + + >>> banded({1: (1, 2, 3), -1: (4, 5, 6), 0: x}) + Matrix([ + [x, 1, 0, 0], + [4, x, 2, 0], + [0, 5, x, 3], + [0, 0, 6, x]]) + + A function accepting a single argument can be used to fill the + diagonal as a function of diagonal index (which starts at 0). + The size (or shape) of the matrix must be given to obtain more + than a 1x1 matrix: + + >>> s = lambda d: (1 + d)*2 + >>> banded(5, {0: s, 2: s, -2: 2}) + Matrix([ + [1, 0, 1, 0, 0], + [0, 4, 0, 4, 0], + [2, 0, 9, 0, 9], + [0, 2, 0, 16, 0], + [0, 0, 2, 0, 25]]) + + The diagonal of matrices placed on a diagonal will coincide + with the indicated diagonal: + + >>> vert = Matrix([1, 2, 3]) + >>> banded({0: vert}, cols=3) + Matrix([ + [1, 0, 0], + [2, 1, 0], + [3, 2, 1], + [0, 3, 2], + [0, 0, 3]]) + + >>> banded(4, {0: ones(2)}) + Matrix([ + [1, 1, 0, 0], + [1, 1, 0, 0], + [0, 0, 1, 1], + [0, 0, 1, 1]]) + + Errors are raised if the designated size will not hold + all values an integral number of times. Here, the rows + are designated as odd (but an even number is required to + hold the off-diagonal 2x2 ones): + + >>> banded({0: 2, 1: ones(2)}, rows=5) + Traceback (most recent call last): + ... + ValueError: + sequence does not fit an integral number of times in the matrix + + And here, an even number of rows is given...but the square + matrix has an even number of columns, too. As we saw + in the previous example, an odd number is required: + + >>> banded(4, {0: 2, 1: ones(2)}) # trying to make 4x4 and cols must be odd + Traceback (most recent call last): + ... + ValueError: + sequence does not fit an integral number of times in the matrix + + A way around having to count rows is to enclosing matrix elements + in a tuple and indicate the desired number of them to the right: + + >>> banded({0: 2, 2: (ones(2),)3}) + Matrix([ + [2, 0, 1, 1, 0, 0, 0, 0], + [0, 2, 1, 1, 0, 0, 0, 0], + [0, 0, 2, 0, 1, 1, 0, 0], + [0, 0, 0, 2, 1, 1, 0, 0], + [0, 0, 0, 0, 2, 0, 1, 1], + [0, 0, 0, 0, 0, 2, 1, 1]]) + + An error will be raised if more than one value + is written to a given entry. Here, the ones overlap + with the main diagonal if they are placed on the + first diagonal: + + >>> banded({0: (2,)5, 1: (ones(2),)3}) + Traceback (most recent call last): + ... + ValueError: collision at (1, 1) + + By placing a 0 at the bottom left of the 2x2 matrix of + ones, the collision is avoided: + + >>> u2 = Matrix([ + ... [1, 1], + ... [0, 1]]) + >>> banded({0: [2]5, 1: [u2]3}) + Matrix([ + [2, 1, 1, 0, 0, 0, 0], + [0, 2, 1, 0, 0, 0, 0], + [0, 0, 2, 1, 1, 0, 0], + [0, 0, 0, 2, 1, 0, 0], + [0, 0, 0, 0, 2, 1, 1], + [0, 0, 0, 0, 0, 0, 1]]) + """ + from sympy import Dict, Dummy, SparseMatrix + try: + if len(args) not in (1, 2, 3): + raise TypeError + if not isinstance(args[-1], (dict, Dict)): + raise TypeError + if len(args) == 1: + rows = kwargs.get('rows', None) + cols = kwargs.get('cols', None) + if rows is not None: + rows = as_int(rows) + if cols is not None: + cols = as_int(cols) + elif len(args) == 2: + rows = cols = as_int(args[0]) + else: + rows, cols = map(as_int, args[:2]) + # fails with ValueError if any keys are not ints + _ = all(as_int(k) for k in args[-1]) + except (ValueError, TypeError): + raise TypeError(filldedent( + '''unrecognized input to banded: + expecting [[row,] col,] {int: value}''')) + def rc(d): + # return row,col coord of diagonal start + r = -d if d < 0 else 0 + c = 0 if r else d + return r, c + smat = {} + undone = [] + tba = Dummy() + # first handle objects with size + for d, v in args[-1].items(): + r, c = rc(d) + # note: only list and tuple are recognized since this + # will allow other Basic objects like Tuple + # into the matrix if so desired + if isinstance(v, (list, tuple)): + extra = 0 + for i, vi in enumerate(v): + i += extra + if is_sequence(vi): + vi = SparseMatrix(vi) + smat[r + i, c + i] = vi + extra += min(vi.shape) - 1 + else: + smat[r + i, c + i] = vi + elif is_sequence(v): + v = SparseMatrix(v) + rv, cv = v.shape + if rows and cols: + nr, xr = divmod(rows - r, rv) + nc, xc = divmod(cols - c, cv) + x = xr or xc + do = min(nr, nc) + elif rows: + do, x = divmod(rows - r, rv) + elif cols: + do, x = divmod(cols - c, cv) + else: + do = 1 + x = 0 + if x: + raise ValueError(filldedent(''' + sequence does not fit an integral number of times + in the matrix''')) + j = min(v.shape) + for i in range(do): + smat[r, c] = v + r += j + c += j + elif v: + smat[r, c] = tba + undone.append((d, v)) + s = SparseMatrix(None, smat) # to expand matrices + smat = s._smat + # check for dim errors here + if rows is not None and rows < s.rows: + raise ValueError('Designated rows %s < needed %s' % (rows, s.rows)) + if cols is not None and cols < s.cols: + raise ValueError('Designated cols %s < needed %s' % (cols, s.cols)) + if rows is cols is None: + rows = s.rows + cols = s.cols + elif rows is not None and cols is None: + cols = max(rows, s.cols) + elif cols is not None and rows is None: + rows = max(cols, s.rows) + def update(i, j, v): + # update smat and make sure there are + # no collisions + if v: + if (i, j) in smat and smat[i, j] not in (tba, v): + raise ValueError('collision at %s' % ((i, j),)) + smat[i, j] = v + if undone: + for d, vi in undone: + r, c = rc(d) + v = vi if callable(vi) else lambda _: vi + i = 0 + while r + i < rows and c + i < cols: + update(r + i, c + i, v(i)) + i += 1 + return SparseMatrix(rows, cols, smat) diff --git a/sympy/polys/polytools.py b/sympy/polys/polytools.py index f4ef829b03eb..418ac6e5aad0 100644 --- a/sympy/polys/polytools.py +++ b/sympy/polys/polytools.py @@ -635,7 +635,7 @@ def ltrim(f, gen): for monom, coeff in rep.items(): - if any(i for i in monom[:j]): + if any(monom[:j]): # some generator is used in the portion to be trimmed raise PolynomialError("can't left trim %s" % f) diff --git a/sympy/solvers/ode.py b/sympy/solvers/ode.py index 21ddc9e40e5a..afc138caa71b 100644 --- a/sympy/solvers/ode.py +++ b/sympy/solvers/ode.py @@ -6284,7 +6284,7 @@ def lie_heuristic_bivariate(match, comp=False): soldict = solve(polyy.values(), symset) if isinstance(soldict, list): soldict = soldict[0] - if any(x for x in soldict.values()): + if any(soldict.values()): xired = xieq.subs(soldict) etared = etaeq.subs(soldict) # Scaling is done by substituting one for the parameters @@ -6351,7 +6351,7 @@ def lie_heuristic_chi(match, comp=False): soldict = solve(cpoly.values(), solsyms) if isinstance(soldict, list): soldict = soldict[0] - if any(x for x in soldict.values()): + if any(soldict.values()): chieq = chieq.subs(soldict) dict_ = dict((sym, 1) for sym in solsyms) chieq = chieq.subs(dict_) diff --git a/sympy/solvers/polysys.py b/sympy/solvers/polysys.py index 004fdb2fa875..aa22a1df93f9 100644 --- a/sympy/solvers/polysys.py +++ b/sympy/solvers/polysys.py @@ -162,7 +162,7 @@ def solve_generic(polys, opt): def _is_univariate(f): """Returns True if 'f' is univariate in its last variable. """ for monom in f.monoms(): - if any(m for m in monom[:-1]): + if any(monom[:-1]): return False return True	diff --git a/sympy/matrices/tests/test_commonmatrix.py b/sympy/matrices/tests/test_commonmatrix.py index f71501f1216e..8daa32508411 100644 --- a/sympy/matrices/tests/test_commonmatrix.py +++ b/sympy/matrices/tests/test_commonmatrix.py @@ -308,7 +308,7 @@ def test_vstack(): # PropertiesOnlyMatrix tests def test_atoms(): m = PropertiesOnlyMatrix(2, 2, [1, 2, x, 1 - 1/x]) - assert m.atoms() == {S(1),S(2),S(-1), x} + assert m.atoms() == {S(1), S(2), S(-1), x} assert m.atoms(Symbol) == {x} @@ -423,8 +423,8 @@ def test_is_lower(): def test_is_square(): - m = PropertiesOnlyMatrix([[1],[1]]) - m2 = PropertiesOnlyMatrix([[2,2],[2,2]]) + m = PropertiesOnlyMatrix([[1], [1]]) + m2 = PropertiesOnlyMatrix([[2, 2], [2, 2]]) assert not m.is_square assert m2.is_square @@ -461,9 +461,11 @@ def test_is_zero(): def test_values(): - assert set(PropertiesOnlyMatrix(2,2,[0,1,2,3]).values()) == set([1,2,3]) + assert set(PropertiesOnlyMatrix(2, 2, [0, 1, 2, 3] + ).values()) == set([1, 2, 3]) x = Symbol('x', real=True) - assert set(PropertiesOnlyMatrix(2,2,[x,0,0,1]).values()) == set([x,1]) + assert set(PropertiesOnlyMatrix(2, 2, [x, 0, 0, 1] + ).values()) == set([x, 1]) # OperationsOnlyMatrix tests @@ -481,10 +483,12 @@ def test_adjoint(): def test_as_real_imag(): - m1 = OperationsOnlyMatrix(2,2,[1,2,3,4]) - m3 = OperationsOnlyMatrix(2,2,[1+S.ImaginaryUnit,2+2S.ImaginaryUnit,3+3S.ImaginaryUnit,4+4S.ImaginaryUnit]) + m1 = OperationsOnlyMatrix(2, 2, [1, 2, 3, 4]) + m3 = OperationsOnlyMatrix(2, 2, + [1 + S.ImaginaryUnit, 2 + 2S.ImaginaryUnit, + 3 + 3S.ImaginaryUnit, 4 + 4S.ImaginaryUnit]) - a,b = m3.as_real_imag() + a, b = m3.as_real_imag() assert a == m1 assert b == m1 @@ -508,7 +512,7 @@ def test_conjugate(): def test_doit(): - a = OperationsOnlyMatrix([[Add(x,x, evaluate=False)]]) + a = OperationsOnlyMatrix([[Add(x, x, evaluate=False)]]) assert a[0] != 2x assert a.doit() == Matrix([[2x]]) @@ -606,7 +610,7 @@ def test_xreplace(): def test_permute(): a = OperationsOnlyMatrix(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]) - raises(IndexError, lambda: a.permute([[0,5]])) + raises(IndexError, lambda: a.permute([[0, 5]])) b = a.permute_rows([[0, 2], [0, 1]]) assert a.permute([[0, 2], [0, 1]]) == b == Matrix([ [5, 6, 7, 8], @@ -781,7 +785,7 @@ def test_div(): # DeterminantOnlyMatrix tests def test_det(): - a = DeterminantOnlyMatrix(2,3,[1,2,3,4,5,6]) + a = DeterminantOnlyMatrix(2, 3, [1, 2, 3, 4, 5, 6]) raises(NonSquareMatrixError, lambda: a.det()) z = zeros_Determinant(2) @@ -790,11 +794,12 @@ def test_det(): assert ey.det() == 1 x = Symbol('x') - a = DeterminantOnlyMatrix(0,0,[]) - b = DeterminantOnlyMatrix(1,1,[5]) - c = DeterminantOnlyMatrix(2,2,[1,2,3,4]) - d = DeterminantOnlyMatrix(3,3,[1,2,3,4,5,6,7,8,8]) - e = DeterminantOnlyMatrix(4,4,[x,1,2,3,4,5,6,7,2,9,10,11,12,13,14,14]) + a = DeterminantOnlyMatrix(0, 0, []) + b = DeterminantOnlyMatrix(1, 1, [5]) + c = DeterminantOnlyMatrix(2, 2, [1, 2, 3, 4]) + d = DeterminantOnlyMatrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 8]) + e = DeterminantOnlyMatrix(4, 4, + [x, 1, 2, 3, 4, 5, 6, 7, 2, 9, 10, 11, 12, 13, 14, 14]) # the method keyword for `det` doesn't kick in until 4x4 matrices, # so there is no need to test all methods on smaller ones @@ -811,7 +816,8 @@ def test_det(): def test_adjugate(): x = Symbol('x') - e = DeterminantOnlyMatrix(4,4,[x,1,2,3,4,5,6,7,2,9,10,11,12,13,14,14]) + e = DeterminantOnlyMatrix(4, 4, + [x, 1, 2, 3, 4, 5, 6, 7, 2, 9, 10, 11, 12, 13, 14, 14]) adj = Matrix([ [ 4, -8, 4, 0], @@ -822,13 +828,14 @@ def test_adjugate(): assert e.adjugate(method='bareiss') == adj assert e.adjugate(method='berkowitz') == adj - a = DeterminantOnlyMatrix(2,3,[1,2,3,4,5,6]) + a = DeterminantOnlyMatrix(2, 3, [1, 2, 3, 4, 5, 6]) raises(NonSquareMatrixError, lambda: a.adjugate()) def test_cofactor_and_minors(): x = Symbol('x') - e = DeterminantOnlyMatrix(4,4,[x,1,2,3,4,5,6,7,2,9,10,11,12,13,14,14]) + e = DeterminantOnlyMatrix(4, 4, + [x, 1, 2, 3, 4, 5, 6, 7, 2, 9, 10, 11, 12, 13, 14, 14]) m = Matrix([ [ x, 1, 3], @@ -844,31 +851,32 @@ def test_cofactor_and_minors(): [4, 5, 6], [2, 9, 10]]) - assert e.minor_submatrix(1,2) == m - assert e.minor_submatrix(-1,-1) == sub - assert e.minor(1,2) == -17x - 142 - assert e.cofactor(1,2) == 17x + 142 + assert e.minor_submatrix(1, 2) == m + assert e.minor_submatrix(-1, -1) == sub + assert e.minor(1, 2) == -17x - 142 + assert e.cofactor(1, 2) == 17x + 142 assert e.cofactor_matrix() == cm assert e.cofactor_matrix(method="bareiss") == cm assert e.cofactor_matrix(method="berkowitz") == cm - raises(ValueError, lambda: e.cofactor(4,5)) - raises(ValueError, lambda: e.minor(4,5)) - raises(ValueError, lambda: e.minor_submatrix(4,5)) + raises(ValueError, lambda: e.cofactor(4, 5)) + raises(ValueError, lambda: e.minor(4, 5)) + raises(ValueError, lambda: e.minor_submatrix(4, 5)) - a = DeterminantOnlyMatrix(2,3,[1,2,3,4,5,6]) - assert a.minor_submatrix(0,0) == Matrix([[5, 6]]) + a = DeterminantOnlyMatrix(2, 3, [1, 2, 3, 4, 5, 6]) + assert a.minor_submatrix(0, 0) == Matrix([[5, 6]]) - raises(ValueError, lambda: DeterminantOnlyMatrix(0,0,[]).minor_submatrix(0,0)) - raises(NonSquareMatrixError, lambda: a.cofactor(0,0)) - raises(NonSquareMatrixError, lambda: a.minor(0,0)) + raises(ValueError, lambda: + DeterminantOnlyMatrix(0, 0, []).minor_submatrix(0, 0)) + raises(NonSquareMatrixError, lambda: a.cofactor(0, 0)) + raises(NonSquareMatrixError, lambda: a.minor(0, 0)) raises(NonSquareMatrixError, lambda: a.cofactor_matrix()) def test_charpoly(): x, y = Symbol('x'), Symbol('y') - m = DeterminantOnlyMatrix(3,3,[1,2,3,4,5,6,7,8,9]) + m = DeterminantOnlyMatrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9]) assert eye_Determinant(3).charpoly(x) == Poly((x - 1)3, x) assert eye_Determinant(3).charpoly(y) == Poly((y - 1)3, y) @@ -1007,7 +1015,7 @@ def verify_row_null_space(mat, rows, nulls): [ 1], [-2], [ 1]])] - rows = [a[i,:] for i in range(a.rows)] + rows = [a[i, :] for i in range(a.rows)] a_echelon = a.echelon_form() assert a_echelon.is_echelon verify_row_null_space(a, rows, nulls) @@ -1015,7 +1023,7 @@ def verify_row_null_space(mat, rows, nulls): a = ReductionsOnlyMatrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 8]) nulls = [] - rows = [a[i,:] for i in range(a.rows)] + rows = [a[i, :] for i in range(a.rows)] a_echelon = a.echelon_form() assert a_echelon.is_echelon verify_row_null_space(a, rows, nulls) @@ -1029,7 +1037,7 @@ def verify_row_null_space(mat, rows, nulls): [-S(3)/2], [ 0], [ 1]])] - rows = [a[i,:] for i in range(a.rows)] + rows = [a[i, :] for i in range(a.rows)] a_echelon = a.echelon_form() assert a_echelon.is_echelon verify_row_null_space(a, rows, nulls) @@ -1040,7 +1048,7 @@ def verify_row_null_space(mat, rows, nulls): [ 0], [ -3], [ 1]])] - rows = [a[i,:] for i in range(a.rows)] + rows = [a[i, :] for i in range(a.rows)] a_echelon = a.echelon_form() assert a_echelon.is_echelon verify_row_null_space(a, rows, nulls) @@ -1054,7 +1062,7 @@ def verify_row_null_space(mat, rows, nulls): [ 0], [-1], [ 1]])] - rows = [a[i,:] for i in range(a.rows)] + rows = [a[i, :] for i in range(a.rows)] a_echelon = a.echelon_form() assert a_echelon.is_echelon verify_row_null_space(a, rows, nulls) @@ -1064,7 +1072,7 @@ def verify_row_null_space(mat, rows, nulls): [-1], [1], [0]])] - rows = [a[i,:] for i in range(a.rows)] + rows = [a[i, :] for i in range(a.rows)] a_echelon = a.echelon_form() assert a_echelon.is_echelon verify_row_null_space(a, rows, nulls) @@ -1137,24 +1145,24 @@ def test_rref(): # SpecialOnlyMatrix tests def test_eye(): - assert list(SpecialOnlyMatrix.eye(2,2)) == [1, 0, 0, 1] + assert list(SpecialOnlyMatrix.eye(2, 2)) == [1, 0, 0, 1] assert list(SpecialOnlyMatrix.eye(2)) == [1, 0, 0, 1] assert type(SpecialOnlyMatrix.eye(2)) == SpecialOnlyMatrix assert type(SpecialOnlyMatrix.eye(2, cls=Matrix)) == Matrix def test_ones(): - assert list(SpecialOnlyMatrix.ones(2,2)) == [1, 1, 1, 1] + assert list(SpecialOnlyMatrix.ones(2, 2)) == [1, 1, 1, 1] assert list(SpecialOnlyMatrix.ones(2)) == [1, 1, 1, 1] - assert SpecialOnlyMatrix.ones(2,3) == Matrix([[1, 1, 1], [1, 1, 1]]) + assert SpecialOnlyMatrix.ones(2, 3) == Matrix([[1, 1, 1], [1, 1, 1]]) assert type(SpecialOnlyMatrix.ones(2)) == SpecialOnlyMatrix assert type(SpecialOnlyMatrix.ones(2, cls=Matrix)) == Matrix def test_zeros(): - assert list(SpecialOnlyMatrix.zeros(2,2)) == [0, 0, 0, 0] + assert list(SpecialOnlyMatrix.zeros(2, 2)) == [0, 0, 0, 0] assert list(SpecialOnlyMatrix.zeros(2)) == [0, 0, 0, 0] - assert SpecialOnlyMatrix.zeros(2,3) == Matrix([[0, 0, 0], [0, 0, 0]]) + assert SpecialOnlyMatrix.zeros(2, 3) == Matrix([[0, 0, 0], [0, 0, 0]]) assert type(SpecialOnlyMatrix.zeros(2)) == SpecialOnlyMatrix assert type(SpecialOnlyMatrix.zeros(2, cls=Matrix)) == Matrix @@ -1464,8 +1472,10 @@ def test_jordan_form(): P, J = A.jordan_form() assert simplify(PJP.inv()) == A - assert EigenOnlyMatrix(1,1,[1]).jordan_form() == (Matrix([1]), Matrix([1])) - assert EigenOnlyMatrix(1,1,[1]).jordan_form(calc_transform=False) == Matrix([1]) + assert EigenOnlyMatrix(1, 1, [1]).jordan_form() == ( + Matrix([1]), Matrix([1])) + assert EigenOnlyMatrix(1, 1, [1]).jordan_form( + calc_transform=False) == Matrix([1]) # make sure if we cannot factor the characteristic polynomial, we raise an error m = Matrix([[3, 0, 0, 0, -3], [0, -3, -3, 0, 3], [0, 3, 0, 3, 0], [0, 0, 3, 0, 3], [3, 0, 0, 3, 0]]) @@ -1538,7 +1548,7 @@ def test_jacobian2(): m = CalculusOnlyMatrix(2, 2, [1, 2, 3, 4]) m2 = CalculusOnlyMatrix(4, 1, [1, 2, 3, 4]) - raises(TypeError, lambda: m.jacobian(Matrix([1,2]))) + raises(TypeError, lambda: m.jacobian(Matrix([1, 2]))) raises(TypeError, lambda: m2.jacobian(m)) @@ -1550,7 +1560,7 @@ def test_limit(): def test_issue_13774(): M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) - v = [1,1,1] + v = [1, 1, 1] raises(TypeError, lambda: Mv) raises(TypeError, lambda: vM) diff --git a/sympy/matrices/tests/test_sparsetools.py b/sympy/matrices/tests/test_sparsetools.py index 0782f2e51144..43634a3c53c5 100644 --- a/sympy/matrices/tests/test_sparsetools.py +++ b/sympy/matrices/tests/test_sparsetools.py @@ -1,5 +1,6 @@ -from sympy.matrices.sparsetools import _doktocsr, _csrtodok -from sympy import SparseMatrix +from sympy.matrices.sparsetools import _doktocsr, _csrtodok, banded +from sympy import eye, ones, zeros, Matrix, SparseMatrix +from sympy.utilities.pytest import raises def test_doktocsr(): @@ -36,3 +37,93 @@ def test_csrtodok(): assert _csrtodok(j) == SparseMatrix(5, 8, {(0, 2): 11, (2, 4): 15, (3, 1): 12, (4, 2): 15}) assert _csrtodok(k) == SparseMatrix(3, 3, {(0, 2): 1, (2, 1): 3}) + + +def test_banded(): + raises(TypeError, lambda: banded()) + raises(TypeError, lambda: banded(1)) + raises(TypeError, lambda: banded(1, 2)) + raises(TypeError, lambda: banded(1, 2, 3)) + raises(TypeError, lambda: banded(1, 2, 3, 4)) + raises(ValueError, lambda: banded({0: (1, 2)}, rows=1)) + raises(ValueError, lambda: banded({0: (1, 2)}, cols=1)) + raises(ValueError, lambda: banded(1, {0: (1, 2)})) + raises(ValueError, lambda: banded(2, 1, {0: (1, 2)})) + raises(ValueError, lambda: banded(1, 2, {0: (1, 2)})) + + assert isinstance(banded(2, 4, {}), SparseMatrix) + assert banded(2, 4, {}) == zeros(2, 4) + assert banded({0: 0, 1: 0}) == zeros(0) + assert banded({0: Matrix([1, 2])}) == Matrix([1, 2]) + assert banded({1: [1, 2, 3, 0], -1: [4, 5, 6]}) == \ + banded({1: (1, 2, 3), -1: (4, 5, 6)}) == \ + Matrix([ + [0, 1, 0, 0], + [4, 0, 2, 0], + [0, 5, 0, 3], + [0, 0, 6, 0]]) + assert banded(3, 4, {-1: 1, 0: 2, 1: 3}) == \ + Matrix([ + [2, 3, 0, 0], + [1, 2, 3, 0], + [0, 1, 2, 3]]) + s = lambda d: (1 + d)*2 + assert banded(5, {0: s, 2: s}) == \ + Matrix([ + [1, 0, 1, 0, 0], + [0, 4, 0, 4, 0], + [0, 0, 9, 0, 9], + [0, 0, 0, 16, 0], + [0, 0, 0, 0, 25]]) + assert banded(2, {0: 1}) == \ + Matrix([ + [1, 0], + [0, 1]]) + assert banded(2, 3, {0: 1}) == \ + Matrix([ + [1, 0, 0], + [0, 1, 0]]) + vert = Matrix([1, 2, 3]) + assert banded({0: vert}, cols=3) == \ + Matrix([ + [1, 0, 0], + [2, 1, 0], + [3, 2, 1], + [0, 3, 2], + [0, 0, 3]]) + assert banded(4, {0: ones(2)}) == \ + Matrix([ + [1, 1, 0, 0], + [1, 1, 0, 0], + [0, 0, 1, 1], + [0, 0, 1, 1]]) + raises(ValueError, lambda: banded({0: 2, 1: ones(2)}, rows=5)) + assert banded({0: 2, 2: (ones(2),)3}) == \ + Matrix([ + [2, 0, 1, 1, 0, 0, 0, 0], + [0, 2, 1, 1, 0, 0, 0, 0], + [0, 0, 2, 0, 1, 1, 0, 0], + [0, 0, 0, 2, 1, 1, 0, 0], + [0, 0, 0, 0, 2, 0, 1, 1], + [0, 0, 0, 0, 0, 2, 1, 1]]) + raises(ValueError, lambda: banded({0: (2,)5, 1: (ones(2),)3})) + u2 = Matrix([[1, 1], [0, 1]]) + assert banded({0: (2,)5, 1: (u2,)3}) == \ + Matrix([ + [2, 1, 1, 0, 0, 0, 0], + [0, 2, 1, 0, 0, 0, 0], + [0, 0, 2, 1, 1, 0, 0], + [0, 0, 0, 2, 1, 0, 0], + [0, 0, 0, 0, 2, 1, 1], + [0, 0, 0, 0, 0, 0, 1]]) + assert banded({0:(0, ones(2)), 2: 2}) == \ + Matrix([ + [0, 0, 2], + [0, 1, 1], + [0, 1, 1]]) + raises(ValueError, lambda: banded({0: (0, ones(2)), 1: 2})) + assert banded({0: 1}, cols=3) == banded({0: 1}, rows=3) == eye(3) + assert banded({1: 1}, rows=3) == Matrix([ + [0, 1, 0], + [0, 0, 1], + [0, 0, 0]])		[ { "components": [ { "doc": "Returns a SparseMatrix from the given dictionary describing\nthe diagonals of the matrix. The keys are positive for upper\ndiagonals and negative for those below the main diagonal. The\nvalues may be:\n * expressions or single-argument functions,\n * lists or tupl...	[ "test_doktocsr", "test_csrtodok" ]	[ "test__MinimalMatrix", "test_vec", "test_tolist", "test_row_col_del", "test_get_diag_blocks1", "test_get_diag_blocks2", "test_shape", "test_reshape", "test_row_col", "test_row_join", "test_col_join", "test_row_insert", "test_col_insert", "test_extract", "test_hstack", "test_vstack", ...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> banded matrix construction <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> closes #16180 as alternate fixes #16178 #### Brief description of what is fixed or changed A syntax is proposed whereby banded matrices can be created. The input to `banded` is a dictionary containing keys for the diagonal to fill, and values containing information about what to put on the diagonal: ``` {0: 1} - 1s on the main diagonal {0: x, 1:1} - an upper Jordan-block matrix {1: (1, 2, 3), -1: (4, 5, 6)} - 1, 2, 3 on the 1st diag above main and 4, 5, 6 on the diagonal below the main ``` The values above can also be matrices/lists or single argument functions which calculate the value on the diagonal based on the displacement along the diagonal. #### Other comments This is not a class of matrix, it is just a helper function for creating the matrix. The rationale for this is that one should not need to instantiate a full matrix if only needing to define values down a few diagonals. It automatically comes back as a SparseMatrix which can be fed to any other matrix constructor if another type is needed (e.g. dense). #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - matrices - `banded` added to sparsetools.py as a helper to create a banded matrices <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/matrices/sparsetools.py] (definition of banded:) def banded(args, kwargs): """Returns a SparseMatrix from the given dictionary describing the diagonals of the matrix. The keys are positive for upper diagonals and negative for those below the main diagonal. The values may be: expressions or single-argument functions, * lists or tuples of values, * matrices Unless dimensions are given, the size of the returned matrix will be large enough to contain the largest non-zero value provided. kwargs ====== rows : rows of the resulting matrix; computed if not given. cols : columns of the resulting matrix; computed if not given. Examples ======== >>> from sympy import banded, ones, Matrix >>> from sympy.abc import x If explicit values are given in tuples, the matrix will autosize to contain all values, otherwise a single value is filled onto the entire diagonal: >>> banded({1: (1, 2, 3), -1: (4, 5, 6), 0: x}) Matrix([ [x, 1, 0, 0], [4, x, 2, 0], [0, 5, x, 3], [0, 0, 6, x]]) A function accepting a single argument can be used to fill the diagonal as a function of diagonal index (which starts at 0). The size (or shape) of the matrix must be given to obtain more than a 1x1 matrix: >>> s = lambda d: (1 + d)*2 >>> banded(5, {0: s, 2: s, -2: 2}) Matrix([ [1, 0, 1, 0, 0], [0, 4, 0, 4, 0], [2, 0, 9, 0, 9], [0, 2, 0, 16, 0], [0, 0, 2, 0, 25]]) The diagonal of matrices placed on a diagonal will coincide with the indicated diagonal: >>> vert = Matrix([1, 2, 3]) >>> banded({0: vert}, cols=3) Matrix([ [1, 0, 0], [2, 1, 0], [3, 2, 1], [0, 3, 2], [0, 0, 3]]) >>> banded(4, {0: ones(2)}) Matrix([ [1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 1], [0, 0, 1, 1]]) Errors are raised if the designated size will not hold all values an integral number of times. Here, the rows are designated as odd (but an even number is required to hold the off-diagonal 2x2 ones): >>> banded({0: 2, 1: ones(2)}, rows=5) Traceback (most recent call last): ... ValueError: sequence does not fit an integral number of times in the matrix And here, an even number of rows is given...but the square matrix has an even number of columns, too. As we saw in the previous example, an odd number is required: >>> banded(4, {0: 2, 1: ones(2)}) # trying to make 4x4 and cols must be odd Traceback (most recent call last): ... ValueError: sequence does not fit an integral number of times in the matrix A way around having to count rows is to enclosing matrix elements in a tuple and indicate the desired number of them to the right: >>> banded({0: 2, 2: (ones(2),)3}) Matrix([ [2, 0, 1, 1, 0, 0, 0, 0], [0, 2, 1, 1, 0, 0, 0, 0], [0, 0, 2, 0, 1, 1, 0, 0], [0, 0, 0, 2, 1, 1, 0, 0], [0, 0, 0, 0, 2, 0, 1, 1], [0, 0, 0, 0, 0, 2, 1, 1]]) An error will be raised if more than one value is written to a given entry. Here, the ones overlap with the main diagonal if they are placed on the first diagonal: >>> banded({0: (2,)5, 1: (ones(2),)3}) Traceback (most recent call last): ... ValueError: collision at (1, 1) By placing a 0 at the bottom left of the 2x2 matrix of ones, the collision is avoided: >>> u2 = Matrix([ ... [1, 1], ... [0, 1]]) >>> banded({0: [2]5, 1: [u2]3}) Matrix([ [2, 1, 1, 0, 0, 0, 0], [0, 2, 1, 0, 0, 0, 0], [0, 0, 2, 1, 1, 0, 0], [0, 0, 0, 2, 1, 0, 0], [0, 0, 0, 0, 2, 1, 1], [0, 0, 0, 0, 0, 0, 1]])""" (definition of banded.rc:) def rc(d): (definition of banded.update:) def update(i, j, v): [end of new definitions in sympy/matrices/sparsetools.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Modified function for easy creation of banded matrices <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs Fixes #16178 <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed In the above mentioned way of passing a dictionary giving diagonal number and the value, I was successful in implementing it for dictionary values as just numbers or as lists in case if the values for the diagonal are not all the same. ``` >>> Matrix.diag({0: 1, 1: 2},rows=3,cols=4) Matrix([ [1, 2, 0, 0], [0, 1, 2, 0], [0, 0, 1, 2]]) >>> Matrix.diag({1: [1,2,3],0:1,-1:[-2,3]}, rows=3, cols=4) Matrix([ [ 1, 1, 0, 0], [-2, 1, 2, 0], [ 0, 3, 1, 3]]) >>> Matrix.diag({1: [1,2,3],0:1,-1:[-2,3,4]}, rows=3, cols=4) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "sympy/matrices/common.py", line 773, in diag raise ValueError("The size of list provided should match the diagonal size") ValueError: The size of list provided should match the diagonal size ``` when the value of dictionary is a function ``` >>> Matrix.diag({1: [1,2,3],0:(lambda i, j: i + 1) ,-1:[-2,3]}, rows=3, cols=4) Matrix([ [ 1, 1, 0, 0], [-2, 2, 2, 0], [ 0, 3, 3, 3]]) >>> Matrix.diag({-1: [-1, -2], 0: lambda i, j: i + j, 1: lambda d: 2d + 1,2:4}, rows=3, cols=4) Matrix([ [ 0, 1, 4, 0], [-1, 2, 3, 4], [ 0, -2, 4, 5]]) ``` #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> matrices * Added cases for checking the type of parameters passed and create matrix accordingly in the Matrix.diag function of common.py * Added the functionality where bands off the diagonal can be made by using a dictionary whose keys tell the diagonal <!-- END RELEASE NOTES --> ---------- :white_check_mark: Hi, I am the [SymPy bot](https://github.com/sympy/sympy-bot) (v142). I'm here to help you write a release notes entry. Please read the [guide on how to write release notes](https://github.com/sympy/sympy/wiki/Writing-Release-Notes). Your release notes are in good order. Here is what the release notes will look like: * matrices * Added cases for checking the type of parameters passed and create matrix accordingly in the Matrix.diag function of common.py ([#16180](https://github.com/sympy/sympy/pull/16180) by [@GYeyosi](https://github.com/GYeyosi) and [@smichr](https://github.com/smichr)) * Added the functionality where bands off the diagonal can be made by using a dictionary whose keys tell the diagonal ([#16180](https://github.com/sympy/sympy/pull/16180) by [@GYeyosi](https://github.com/GYeyosi) and [@smichr](https://github.com/smichr)) This will be added to https://github.com/sympy/sympy/wiki/Release-Notes-for-1.4. Note: This comment will be updated with the latest check if you edit the pull request. You need to reload the page to see it. <details><summary>Click here to see the pull request description that was parsed.</summary> <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs Fixes #16178 <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed In the above mentioned way of passing a dictionary giving diagonal number and the value, I was successful in implementing it for dictionary values as just numbers or as lists in case if the values for the diagonal are not all the same. ``` >>> Matrix.diag({0: 1, 1: 2},rows=3,cols=4) Matrix([ [1, 2, 0, 0], [0, 1, 2, 0], [0, 0, 1, 2]]) >>> Matrix.diag({1: [1,2,3],0:1,-1:[-2,3]}, rows=3, cols=4) Matrix([ [ 1, 1, 0, 0], [-2, 1, 2, 0], [ 0, 3, 1, 3]]) >>> Matrix.diag({1: [1,2,3],0:1,-1:[-2,3,4]}, rows=3, cols=4) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "sympy/matrices/common.py", line 773, in diag raise ValueError("The size of list provided should match the diagonal size") ValueError: The size of list provided should match the diagonal size ``` when the value of dictionary is a function ``` >>> Matrix.diag({1: [1,2,3],0:(lambda i, j: i + 1) ,-1:[-2,3]}, rows=3, cols=4) Matrix([ [ 1, 1, 0, 0], [-2, 2, 2, 0], [ 0, 3, 3, 3]]) >>> Matrix.diag({-1: [-1, -2], 0: lambda i, j: i + j, 1: lambda d: 2d + 1,2:4}, rows=3, cols=4) Matrix([ [ 0, 1, 4, 0], [-1, 2, 3, 4], [ 0, -2, 4, 5]]) ``` #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> matrices * Added cases for checking the type of parameters passed and create matrix accordingly in the Matrix.diag function of common.py * Added the functionality where bands off the diagonal can be made by using a dictionary whose keys tell the diagonal <!-- END RELEASE NOTES --> </details><p> Now we have to make sure that it plays nicely with other diagonal elements: ``` >>> M=Matrix;M.diag(11,22,{1:1,3:3,-3:-2,'size':(5,5)},33) Matrix([ [11, 0, 0, 0, 0, 0, 0, 0], [ 0, 22, 0, 0, 0, 0, 0, 0], [ 0, 0, 0, 1, 0, 3, 0, 0], [ 0, 0, 0, 0, 1, 0, 3, 0], [ 0, 0, 0, 0, 0, 1, 0, 0], [ 0, 0, -2, 0, 0, 0, 0, 0], [ 0, 0, 0, -2, 0, 0, 0, 0], [ 0, 0, 0, 0, 0, 0, 0, 33]]) ``` Something like this, maybe? ```diff diff --git a/sympy/matrices/common.py b/sympy/matrices/common.py index 94589d6..2428b18 100644 --- a/sympy/matrices/common.py +++ b/sympy/matrices/common.py @@ -7,6 +7,7 @@ from __future__ import division, print_function from collections import defaultdict +from inspect import isfunction from types import FunctionType from sympy.assumptions.refine import refine @@ -15,13 +16,14 @@ Iterable, as_int, is_sequence, range, reduce) from sympy.core.decorators import call_highest_priority from sympy.core.expr import Expr -from sympy.core.function import count_ops +from sympy.core.function import count_ops, _getnargs from sympy.core.singleton import S from sympy.core.symbol import Symbol from sympy.core.sympify import sympify from sympy.functions import Abs from sympy.simplify import simplify as _simplify from sympy.utilities.iterables import flatten +from sympy.utilities.misc import filldedent class MatrixError(Exception): @@ -733,11 +735,21 @@ def size(m): if hasattr(m, 'rows'): return m.rows, m.cols if isinstance(m, dict): - return kwargs.get('rows'), kwargs.get('cols') + rv = m.pop('size', (kwargs.get('rows'), kwargs.get('cols'))) + if None in rv: + raise ValueError(filldedent(''' + If size is not given in dict the `rows` and `cols` + must be given as arg to diag.''')) + return rv return 1, 1 - - diag_rows = sum(size(m)[0] for m in args) - diag_cols = sum(size(m)[1] for m in args) + dict_sizes = [] + diag_rows = diag_cols = 0 + for m in args: + s = r, c = size(m) + if isinstance(m, dict): + dict_sizes.append(s) + diag_rows += r + diag_cols += c rows = kwargs.get('rows', diag_rows) cols = kwargs.get('cols', diag_cols) if rows < diag_rows or cols < diag_cols: @@ -748,55 +760,62 @@ def size(m): # fill a default dict with the diagonal entries diag_entries = defaultdict(lambda: S.Zero) row_pos, col_pos = 0, 0 + ndict = 0 for m in args: - if hasattr(m, 'rows'): - # in this case, we're a matrix + if hasattr(m, 'rows'): # a matrix for i in range(m.rows): for j in range(m.cols): diag_entries[(i + row_pos, j + col_pos)] = m[i, j] row_pos += m.rows col_pos += m.cols - elif isinstance(m, dict): - # in this case we're a dict + elif not isinstance(m, dict): # a single value + diag_entries[(row_pos, col_pos)] = m + row_pos += 1 + col_pos += 1 + else: # a dict + ix = lambda r, c: (row_pos + r, col_pos + c) + r, c = dict_sizes[ndict] + rmax = r - 1 + cmax = c - 1 for key, value in m.items(): key = as_int(key) - assert(key < diag_rows and key < diag_cols) r_p = 0 if key >= 0 else -key c_p = key if key > 0 else 0 - func_arg = 0 - while (r_p < diag_rows and c_p < diag_cols): - from inspect import isfunction - from sympy.core.function import _getnargs - + if r_p > rmax or c_p > cmax: + raise ValueError(filldedent(''' + dict-specified diagonal index out of range''')) + d = 0 + dlen = d + 1 + while (r_p < diag_rows and c_p < diag_cols and d < dlen): + dlen = min(rmax - r_p + 1, cmax - c_p + 1) if(isinstance(value, list)): - if(len(value) != min(diag_rows - r_p, diag_cols - c_p)): - raise ValueError("The size of list provided should match the diagonal size") + if(len(value) != dlen): + raise ValueError(filldedent(''' + The size of list provided should + match the diagonal size.''')) for i in range(len(value)): - diag_entries[(r_p, c_p)] = value[i] + diag_entries[ix(r_p, c_p)] = value[i] r_p += 1 c_p += 1 elif(isfunction(value)): num_args = _getnargs(value) - # print(num_args) - if(num_args == 2): - diag_entries[(r_p, c_p)] = value(r_p, c_p) - elif(num_args == 1): - diag_entries[(r_p, c_p)] = value(func_arg) - func_arg += 1 + if num_args == 2: + diag_entries[ix(r_p, c_p)] = value(r_p, c_p) + elif num_args == 1: + diag_entries[ix(r_p, c_p)] = value(d) else: - raise ValueError("While passing function as a value in dictionary number of arguments must be either 1 or 2") - r_p += 1 - c_p += 1 + raise ValueError(filldedent(''' + The functions in dict-described + diagonals must have 1 or 2 args.''')) else: - diag_entries[(r_p, c_p)] = value - r_p += 1 - c_p += 1 - - else: - # in this case, we're a single value - diag_entries[(row_pos, col_pos)] = m - row_pos += 1 - col_pos += 1 + diag_entries[ix(r_p, c_p)] = value + r_p += 1 + c_p += 1 + d += 1 + r, c = dict_sizes[ndict] + row_pos += r + col_pos += c + ndict += 1 return klass._eval_diag(rows, cols, diag_entries) @classmethod ``` I didn't consider the case, where dictionary is constricted with some size, other values given. This looks great, I'll add it. But, ``` > + while (r_p < diag_rows and c_p < diag_cols and d < dlen): ``` In this line it must be d <= dlen. The following fails if it was d < dlen ``` >>> Matrix.diag({0: 1, 1: 2},rows=3,cols=4) Matrix([ [1, 2, 0, 0], [0, 1, 2, 0], [0, 0, 0, 0]]) >>> ``` Actual output is ``` >>> Matrix.diag({0: 1, 1: 2},rows=3,cols=4) Matrix([ [1, 2, 0, 0], [0, 1, 2, 0], [0, 0, 1, 2]]) ``` I've made changes accordingly. Perhaps the dict could be a little flexible in size: ```diff diff --git a/sympy/matrices/common.py b/sympy/matrices/common.py index 2428b18..b2fb3ff 100644 --- a/sympy/matrices/common.py +++ b/sympy/matrices/common.py @@ -739,7 +739,7 @@ def size(m): if None in rv: raise ValueError(filldedent(''' If size is not given in dict the `rows` and `cols` - must be given as arg to diag.''')) + must be given as args to diag.''')) return rv return 1, 1 dict_sizes = [] @@ -753,9 +753,17 @@ def size(m): rows = kwargs.get('rows', diag_rows) cols = kwargs.get('cols', diag_cols) if rows < diag_rows or cols < diag_cols: - raise ValueError("A {} x {} diagnal matrix cannot accommodate a" - "diagonal of size at least {} x {}.".format(rows, cols, - diag_rows, diag_cols)) + if len(dict_sizes) == 1 and len(args) > 1: + r, c = dict_sizes[0] + dict_sizes = [ + (r - (diag_rows - rows), c - (diag_cols - cols))] + diag_rows = rows + diag_cols = cols + else: + raise ValueError(filldedent(''' + The diagonal elements need a matrix that is {} x {} + but only {} x {} has been specified.'''.format( + diag_rows, diag_cols, rows, cols))) # fill a default dict with the diagonal entries diag_entries = defaultdict(lambda: S.Zero) ``` Here are some possible tests: ```python >>> Matrix.diag(1, {1:2}, rows=3, cols=4) Matrix([ [1, 0, 0, 0], [0, 0, 2, 0], [0, 0, 0, 2]]) >>> Matrix.diag(1, {1: 2, 'size': (2, 2)}, rows=3, cols=4) Matrix([ [1, 0, 0, 0], [0, 0, 2, 0], [0, 0, 0, 0]]) >>> Matrix.diag(1, {1: 2, 'size': (2, 2)}, 3, rows=4, cols=4) Matrix([ [1, 0, 0, 0], [0, 0, 2, 0], [0, 0, 0, 0], [0, 0, 0, 3]]) >>> Matrix.diag(1, {1:2}, 3, rows=5, cols=5) Matrix([ [1, 0, 0, 0, 0], [0, 0, 2, 0, 0], [0, 0, 0, 2, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 3]]) >>> Matrix.diag(1, {-1: 2}, 3, rows=5, cols=5) Matrix([ [1, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 2, 0, 0, 0], [0, 0, 2, 0, 0], [0, 0, 0, 0, 3]]) ``` What should be the behaviour when user provides with an input of this type? ``` >>> Matrix.diag({0:1}, {1:2}, rows=3, cols=4) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "sympy/matrices/common.py", line 767, in diag diag_rows, diag_cols, rows, cols))) ValueError: The diagonal elements need a matrix that is 6 x 8 but only 3 x 4 has been specified. ``` Should we merge dictionaries? and make it ``` >>> Matrix.diag({0: 1, 1: 2},rows=3,cols=4) Matrix([ [1, 2, 0, 0], [0, 1, 2, 0], [0, 0, 1, 2]]) >>> ``` > Should we merge dictionaries? and make it Interesting that the un-specified size goes to the end of the diagonal whereas ```python >>> Matrix.diag({0: 1, 1: 2,'size':(3,3)},rows=3,cols=4) Matrix([ [1, 2, 0, 0], [0, 1, 2, 0], [0, 0, 1, 0]]) ``` This concatenation of contiguous dicts makes a nice method of being able to say what the diagonal should be, e.g. ``` >>> ones = {1:1, -1:1} >>> Matrix.diag(ones, {0:2x}, rows=4, cols=4) Matrix([ [2x, 1, 0, 0], [ 1, 2x, 1, 0], [ 0, 1, 2x, 1], [ 0, 0, 1, 0]]) ``` # [Codecov](https://codecov.io/gh/sympy/sympy/pull/16180?src=pr&el=h1) Report > Merging [#16180](https://codecov.io/gh/sympy/sympy/pull/16180?src=pr&el=desc) into [master](https://codecov.io/gh/sympy/sympy/commit/faad12d1307099aff62b559a84df40a999b8219c?src=pr&el=desc) will increase coverage by `0.01%`. > The diff coverage is `95.31%`. [![Impacted file tree graph](https://codecov.io/gh/sympy/sympy/pull/16180/graphs/tree.svg?width=650&token=RzuBMaa2lr&height=150&src=pr)](https://codecov.io/gh/sympy/sympy/pull/16180?src=pr&el=tree) ```diff @@ Coverage Diff @@ ## master #16180 +/- ## ========================================== + Coverage 73.14% 73.16% +0.01% ========================================== Files 618 618 Lines 157778 157949 +171 Branches 37116 37159 +43 ========================================== + Hits 115408 115564 +156 - Misses 36831 36833 +2 - Partials 5539 5552 +13 ``` \| [Impacted Files](https://codecov.io/gh/sympy/sympy/pull/16180?src=pr&el=tree) \| Coverage Δ \| \| \|---\|---\|---\| \| [sympy/utilities/misc.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvdXRpbGl0aWVzL21pc2MucHk=) \| `51.61% <0%> (-0.57%)` \| :arrow_down: \| \| [sympy/core/function.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvY29yZS9mdW5jdGlvbi5weQ==) \| `91.06% <42.85%> (-0.16%)` \| :arrow_down: \| \| [sympy/matrices/common.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvbWF0cmljZXMvY29tbW9uLnB5) \| `92.67% <98.36%> (+1.5%)` \| :arrow_up: \| \| [sympy/combinatorics/perm\_groups.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvY29tYmluYXRvcmljcy9wZXJtX2dyb3Vwcy5weQ==) \| `76.58% <0%> (-0.97%)` \| :arrow_down: \| \| [sympy/combinatorics/homomorphisms.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvY29tYmluYXRvcmljcy9ob21vbW9ycGhpc21zLnB5) \| `76.71% <0%> (-0.69%)` \| :arrow_down: \| \| [sympy/stats/rv.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvc3RhdHMvcnYucHk=) \| `84.24% <0%> (-0.41%)` \| :arrow_down: \| \| [sympy/sets/handlers/intersection.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvc2V0cy9oYW5kbGVycy9pbnRlcnNlY3Rpb24ucHk=) \| `91.4% <0%> (-0.4%)` \| :arrow_down: \| \| [sympy/matrices/expressions/matexpr.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvbWF0cmljZXMvZXhwcmVzc2lvbnMvbWF0ZXhwci5weQ==) \| `90.14% <0%> (-0.37%)` \| :arrow_down: \| \| [sympy/polys/densebasic.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvcG9seXMvZGVuc2ViYXNpYy5weQ==) \| `95.96% <0%> (-0.36%)` \| :arrow_down: \| \| [sympy/polys/modulargcd.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvcG9seXMvbW9kdWxhcmdjZC5weQ==) \| `97.36% <0%> (-0.26%)` \| :arrow_down: \| \| ... and [7 more](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree-more) \| \| ------ [Continue to review full report at Codecov](https://codecov.io/gh/sympy/sympy/pull/16180?src=pr&el=continue). > Legend - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta) > `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data` > Powered by [Codecov](https://codecov.io/gh/sympy/sympy/pull/16180?src=pr&el=footer). Last update [faad12d...0fe2aa2](https://codecov.io/gh/sympy/sympy/pull/16180?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments). > Interesting that the un-specified size goes to the end of the diagonal whereas > > ```python > >>> Matrix.diag({0: 1, 1: 2,'size':(3,3)},rows=3,cols=4) > Matrix([ > [1, 2, 0, 0], > [0, 1, 2, 0], > [0, 0, 1, 0]]) > ``` What about this then, from the above discussions. ``` >>> Matrix.diag(1, {-1: 2}, 3, rows=5, cols=5) Matrix([ [1, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 2, 0, 0, 0], [0, 0, 2, 0, 0], [0, 0, 0, 0, 3]]) ``` In the above case, the dictionary is considered for inner 3x3 matrix, cause the other two arguments are just values. How should we deal with something like below, which has different possibilities `Matrix.diag(1, {-1: 2}, 3, {0: 1}, rows=6, cols=6)` where as if sizes are provided it is understandable. ``` >>> Matrix.diag(1, {-1: 2, 'size':(3,3)}, 3,{0: 1, 'size':(3,3)}, rows=9, cols=9) Matrix([ [1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 3, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]]) >>> ``` So, what should I do with the possibility of having multiple dictionaries without their corresponding sizes ? Can you please help me out. After collapsing contiguous dictionaries, if there is more than one dictionary without 'size' key then raise an error. Something like this, perhaps? ```python newargs = [] nosize = 0 for a in args: if newargs and all(isinstance(i, dict) and 'size' not in i for i in (a, newargs[-1])): newargs[-1].updated(a) else: newargs.append(a) if isinstance(a, dict) and 'size' not in a: nosize += 1 if nosize > 1: raise ValueError(filldedent(''' non-contiguous dictionaries must have a size specified, e.g. {'size': (rows, cols), ...}''')) ``` I was just checking on [special block diagonal shapes](https://en.wikipedia.org/wiki/Block_matrix#Block_diagonal_matrices) and see that the "direct sum" is computed with this routine: ```python >>> A=Matrix(((1,2,3),(4,5,6))) >>> B=Matrix(((3,3),(4,4))) >>> Matrix.diag(A, B) # direct sum Matrix([ [1, 2, 3, 0, 0], [4, 5, 6, 0, 0], [0, 0, 0, 3, 3], [0, 0, 0, 4, 4]]) >>> ``` If there is only one dictionary and neither size, rows nor cols, the minimal size can be used: ```python def minsize(d): r = max(0, -min(d)) + 1 c = -min(0, -max(d)) + 1 for k in d: size = len(d[k]) if type(d[k]) is list else 0 r = max(r, abs(k) + size) c = max(c, abs(k) + size) return r, c >>> minsize({2:[4,5,6],-2:[1,2,3]}) (5, 5) >>> Matrix.diag({1:2,-2:1}) Matrix([ [0, 2], [0, 0], [1, 0]]) ``` > If there is only one dictionary and neither size, rows nor cols, the minimal size can be used: Yup, I'm actually implementing this now. I'll add it and push the changes. > Yup, I'm actually implementing this now. I'll add it and push the changes. Done with it, pushed the changes. @smichr can you please review it. I noticed that 1s were trailing out of range in what should be ``` >>> Matrix.diag({1:2,-2:1},4) Matrix([ [0, 2, 0], [0, 0, 0], [1, 0, 0], [0, 0, 4]]) ``` I modified that and tweaked what you have, too. > I was just checking on [special block diagonal shapes](https://en.wikipedia.org/wiki/Block_matrix#Block_diagonal_matrices) and see that the "direct sum" is computed with this routine: The DirectSum can be done as below. ``` class DirectSum(MatrixExpr): def __new__(cls, args): if not args: return GenericZeroMatrix() # This must be removed aggressively in the constructor to avoid # TypeErrors from GenericZeroMatrix().shape args = filter(lambda i: GenericZeroMatrix() != i, args) args = list(map(sympify, args)) validate(args) obj = Basic.__new__(cls, args) return obj def doit(self): return Matrix.diag(self.args) def validate(args): if not all(arg.is_Matrix for arg in args): raise TypeError("Mix of Matrix and Scalar symbols") ``` Should I add it to expressions ? > Should I add it to expressions ? I defer to others more familiar with Matrices. Rather than modify this directly here, I made a [PR to this branch](https://github.com/GYeyosi/sympy/pull/1) which I think you will be able to merge (or comment on before doing so). The function had grown too large. Is it possible to split some parts? The release notes entry should mention which function is actually affected by the change (Matrix.diag). > The release notes entry should mention which function is actually affected by the change (Matrix.diag) I've added it to the Release Notes. The only other thing I was thinking about was a more flexible way to position the filling. Instead of using kerning matrices (which only allow nonnegative motion) we could use keywords 'goto' and 'move' --or something like that--to indicate absolute position or relative motion, e.g. `diag(dict(move=(-2,0)), 1, 2, 3,dict(goto=(0,2)),4,5,6)` > The only other thing I was thinking about was a more flexible way to position the filling. Instead of using kerning matrices (which only allow nonnegative motion) we could use keywords 'goto' and 'move' --or something like that--to indicate absolute position or relative motion, e.g. `diag(dict(move=(-2,0)), 1, 2, 3,dict(goto=(0,2)),4,5,6)` I'm not sure if I understood what you meant exactly, is it like not using the integral keys in the dictionary but use these keywords to specify the position to start the filling? Can you please give an example explaining this. This `diag(dict(move=(-2,0)), 1, 2, 3,dict(goto=(0,2)),4,5,6)` would recreate the docstring example in which the kerning is used. Consider this, `diag({1:2, -2:1, 'move':(-2, 0)}, 1, 2, 3,dict(goto=(0, 2)), 4,5,6)` In the first dictionary, should I move the values down (2 rows) only of that dictionary, or the values 1, 2, 3 also must be moved? and in similar case with goto also. the motion directives would be singletons; they would not appear inside another dictionary. You can see my wip on my diag branch. I haven't yet settled how to compute size so the example I have been giving fails. I have seen the branch you mentioned, in your code the arg_size function can be written this way. ``` def arg_size(args): prev = None o_r, o_c, g_r, g_c, m_r, m_c = 0, 0, 0, 0, 0, 0 max_row, max_col = 0, 0 for a_ in args: a_size = size(a_) if type(a_) is dict and 'goto' in a_: prev = 'goto' prev_size = a_size g_r , g_c = prev_size[0], prev_size[1] continue elif type(a_) is dict and 'move' in a_: prev = 'move' prev_size = a_size continue else: o_r += a_size[0] o_c += a_size[1] if prev is None: if max_row < o_r: max_row = o_r if max_col < o_r: max_col = o_r continue if 'goto' in prev: g_r += a_size[0] g_c += a_size[1] if max_row < g_r: max_row = g_r if max_col < g_c: max_col = g_c elif 'move' in prev: m_r = o_r - prev_size[0] m_c = o_c - prev_size[1] # print(m_r, m_c) if max_row < m_r: max_row = m_r if max_col < m_c: max_col = m_c return max_row, max_col ``` I was working on code from your branch, successfully implemented it for arguments as values, i'm now extending it for matrices, dicts. Also, there are many unnecessary lines in it, needed to be modified. @smichr Can you please review the changes I've just made. Although the code is lengthy now, I hope all possible cases are covered. Can you please check if any test case fails. Does this do the same? ```python def arg_size(args): prev = None max_row, max_col, o_r, o_c = [0]4 for a_ in args: a_size = size(a_) if type(a_) is dict and 'goto' in a_ or 'move' in a_: if 'goto' in a_: prev = 'goto' else: prev = 'move' prev_size = a_size else: R, C = a_size o_r += R o_c += C if prev is None: max_row = o_r max_col = o_c else: r, c = prev_size if prev == 'goto': max_row = max(max_row, R + r) max_col = max(max_col, C + c) else: # 'move' max_row = max(max_row, o_r - r) max_col = max(max_col, o_c - c) return max_row, max_col ``` > Does this do the same? I changed the line `if type(a_) is dict and 'goto' in a_ or 'move' in a_:` to `if type(a_) is dict and ('goto' in a_ or 'move' in a_):` cause the first one raises error if a_ is an integer. It gave the following result for `diag(dict(move=(-2,0)), 1, 2, 3,dict(goto=(0,2)),4,5,6)` of size `(5,3)` whereas it should be `(5,5)` ``` >>> diag(dict(move=(-2,0)), 1, 2, 3,dict(goto=(0,2)),4,5,6) Matrix([ [0, 0, 4], [0, 0, 0], [1, 0, 0], [0, 2, 0], [0, 0, 3]]) ``` I've tried simplifying the code Can you have a look at it and suggest further modifications that can be done. ```python def arg_size(args): prev = None max_row, max_col, o_r, o_c = [0]4 for a_ in args: a_size = size(a_) if type(a_) is dict and ('goto' in a_ or 'move' in a_): p_r, p_c = a_size if 'goto' in a_: prev = 'goto' else: prev = 'move' else: o_r += a_size[0] o_c += a_size[1] if prev is None: max_row, max_col = o_r, o_c elif 'goto' in prev: max_row = max(max_row, p_r + g_r) max_col = max(max_col, p_c + g_c) elif 'move' in prev: max_row = max(max_row, o_r - p_r) max_col = max(max_col, o_c - pc) return max_row, max_col ``` > ```python >prev_size = a_size = size(a_) >if type(a_) is dict and 'goto' in a_: > prev = 'goto' > g_r , g_c = a_size > elif type(a_) is dict and 'move' in a_: > prev = 'move' > ``` prev_size should be changed to `size(a_)` only if a_ is `move`or `goto`, so I've made it ``` a_size = size(a_) if type(a_) is dict and 'goto' in a_: prev = 'goto' prev_size = size(a_) g_r , g_c = a_size elif type(a_) is dict and 'move' in a_: prev = 'move' prev_size = size(a_) ``` > prev_size should be changed only just saw that -- see update code that I last posted I've pushed the changes. Looks good. I got the issue #16233 fixed and added ValueErrors instead of Assertions. coverage of diag was 100% in terms of line coverage the last time I checked (but for some reason the report-writing is not working for the coverage test and I can't check it). update: it's still 100% :arrow_double_up: The new PR will fix the import error. Let's see if anyone else has some ideas about this approach. I see there is still a problem. ```python >>> diag({-2:1}, row=4,cols=4) Matrix([ [0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0]]) should be Matrix([ [0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0], [0, 1, 0, 0]]) ``` > I see there is still a problem. > ```python > >>> diag({-2:1}, row=4,cols=4) > Matrix([ > [0, 0, 0, 0], > [0, 0, 0, 0], > [1, 0, 0, 0]]) > > ``` The keyword to define number of rows is `rows` not `row` This API seems overly complex. It has taken me some time to understand it right now. As an example: ``` A kerning dictionary can be used to reposition the filling: {'move': (row change, col change)}, {'goto': (row, col)}, or {} (to go to the diagonal): >>> diag(7, {'move': (-1, -1)}, 1, 2, 3, {'goto': (0, 2)}, 4, 5, 6, {}, 8) Matrix([ [7, 0, 4, 0, 0, 0], [0, 0, 0, 5, 0, 0], [1, 0, 0, 0, 6, 0], [0, 2, 0, 0, 0, 0], [0, 0, 3, 0, 0, 0], [0, 0, 0, 0, 0, 8]]) ``` I can't really imagine wanting to do something like this and I wouldn't want to try and understand code that was written this way. Wouldn't this example be better written as this: ``` diag({0: [7]+4[0], -2:[1,2,3], 2:[4,5,6]}, 8) ``` Can we draw inspiration from other APIs here like numpy/scipy/Matlab? I don't think any of those has such a state machine API: rather these effects are achieved through composition of many simple primitives. Is it intentional that I can do this: ```julia In [5]: Matrix.diag(1, 2, {'move':(1,-1)}, {0:3}) Out[5]: ⎡1 0⎤ ⎢ ⎥ ⎣0 3⎦ ``` It took me a couple of goes to get the indices right for that move. Is the coordinate system +/+ for upwards and to the right? That makes the horizontal direction alined with increasing indices and the vertical direction reversed. > I can't really imagine wanting to do something like this and I wouldn't want to try and understand code that was written this way. Wouldn't this example be better written as this: > ``` > diag({0: [7]+4[0], -2:[1,2,3], 2:[4,5,6]}, 8) > ``` Either of the two gives out the same matrix as result, but in the former one we use keywords 'goto' and 'move' to indicate absolute position or relative motion whereas latter uses kerning matrices (allow only non-negative motion). > Is it intentional that I can do this: > ```julia > In [5]: Matrix.diag(1, 2, {'move':(1,-1)}, {0:3}) > Out[5]: > ⎡1 0⎤ > ⎢ ⎥ > ⎣0 3⎦ > ``` Yes, I think it should be this way cause it indicates the relative motion of the block `{0: 3}` to a step left and a step up. > Is the coordinate system +/+ for upwards and to the right? That makes the horizontal direction alined with increasing indices and the vertical direction reversed. The coordinate system we chose as of now: 1. If the key is `goto` we need to start filling from than position (index). 2. If the key is `move` and value `(x, y)` we'll relatively move the block x rows up and y cols right. This is the reason in order to move the block down we need to give a negative x. (This convention can be changed if required). @smichr Hope I'm correct with the conventions mentioned above, can you please crosscheck. > can you please crosscheck. yes, but I agree with @oscarbenjamin . I think we can get rid of the kerning. I've reset the code back to the one in which we didn't implement any functionality for `move` and `goto`. I find diag useful for creating block diagonal matrices: ``` In [1]: diag(ones(2), ones(2)) Out[1]: ⎡1 1 0 0⎤ ⎢ ⎥ ⎢1 1 0 0⎥ ⎢ ⎥ ⎢0 0 1 1⎥ ⎢ ⎥ ⎣0 0 1 1⎦ ``` Does this PR affect that? Also do you think there's a reasonable way of using the features here for banded block matrices? I just tried this Pr with: ``` In [2]: diag({-1:ones(2)}, ones(2)) --------------------------------------------------------------------------- TypeError Traceback (most recent call last) ``` > I find diag useful for creating block diagonal matrices: > In [1]: diag(ones(2), ones(2)) > Does this PR affect that? Nope, even now diag is useful for creating block diagonal matrices. > Also do you think there's a reasonable way of using the features here for banded block matrices? > I just tried this Pr with: > > ``` > In [2]: diag({-1:ones(2)}, ones(2)) > --------------------------------------------------------------------------- > TypeError Traceback (most recent call last) > ``` As of now we assumed that the values given in the dictionary can be anyone of lists, functions or a single value. If we implement it to take in matrices also as values...yes we'll be able to get banded block matrices. > As of now we assumed that the values given in the dictionary can be anyone of lists, functions or a single value. If we implement it to take in matrices also as values...yes we'll be able to get banded block matrices. I tried implementing it, but it's very confusing on how the matrix produced should look like. As of now, I think it's better not adding this functionality. ``` a = ones(2) assert diag({0:[1]7, 3:a, -3:-a}) == Matrix([ [ 1, 0, 0, 1, 1, 0, 0], [ 0, 1, 0, 1, 1, 0, 0], [ 0, 0, 1, 0, 0, 1, 1], [-1, -1, 0, 1, 0, 1, 1], [-1, -1, 0, 0, 1, 0, 0], [ 0, 0, -1, -1, 0, 1, 0], [ 0, 0, -1, -1, 0, 0, 1]]) ``` pr pending > reasonable way of using the features here for banded block matrices? ```python >>> diag({-1:ones(2)}, ones(2)) Matrix([ [0, 0, 0, 0], [1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 1], [0, 0, 1, 1]]) >>> diag({-1:ones(2)}, {}, ones(2)) # restart on diag Matrix([ [0, 0, 0, 0], [1, 1, 0, 0], [1, 1, 1, 1], [0, 0, 1, 1]]) >>> diag({-1:ones(2)}, rows=7) Matrix([ [0, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 1, 1, 0]]) ``` > it's very confusing I agree. It will be worth testing this for a while to make sure there are no corners left unchecked. This PR looks really, really complex to me, and I don't understand the API. I don't think we should not attempt to support banded block-matrices (i.e., a matrix off the diagonal) and function arguments (though I could be convinced otherwise, it looks really complicated right now). I would propose adding a `bands={...}` keyword-only argument and limit it to the form `{<band offset>: <number \|\| list>}`. If someone wants to do complicated things with functions, use a function to create a matrix in the first place. For example, ``` def get_band(i,j): return j - i Matrix(5,5, lambda i,j: get_band(i,j)2) ``` As a separate issue, the code formatting of the unit tests should be a separate PR so this one can focus on just new code. --------------------easier creation of banded matrices currently we have the `Matrix.diag` method which allows for easy creation of a single diagonal. To create a banded matrix is a little more difficult. This is the current docstring extract: ``` A given band off the diagonal can be made by padding with a vertical or horizontal "kerning" vector: >>> hpad = Matrix(0, 2, []) >>> vpad = Matrix(2, 0, []) >>> Matrix.diag(vpad, 1, 2, 3, hpad) + Matrix.diag(hpad, 4, 5, 6, vpad) Matrix([ [0, 0, 4, 0, 0], [0, 0, 0, 5, 0], [1, 0, 0, 0, 6], [0, 2, 0, 0, 0], [0, 0, 3, 0, 0]]) ``` And here's a suggestion of how it could be enhanced: ``` This can also be done by passing a dictionary giving the diagonal number and value: >>> Matrix.diag({0: 1, 1: 2}, rows=3, cols=4) Matrix([ [1, 2, 0, 0], [0, 1, 2, 0], [0, 0, 1, 2]]) If the values for the diagonal are not all the same they can be given as a) a list (and a check will be made that there are the right number present) or b) a 2-argument function that will compute the value from the row and column position or c) a single-argument function that will compute the value from the distance along the diagonal: >>> Matrix.diag({ ... -1: [-1, -2], ... 0: lambda i, j: i + 1, ... 1: lambda d: 2d + 1}, ... rows=3, cols=4) ... Matrix([ [ 1, 1, 0, 0], [-1, 2, 3, 0], [ 0, -2, 3, 5]]) Note: it is also possible to create a diagonal matrix with a Piecewise function without using the diag method: >>> Matrix(4,6,lambda i,j: Piecewise((x, Eq(i, j)),(1, Eq(i - 1, j)), (0, True))) Matrix([ [x, 0, 0, 0, 0, 0], [1, x, 0, 0, 0, 0], [0, 1, x, 0, 0, 0], [0, 0, 1, x, 0, 0]]) >>> Matrix(5,5,lambda i,j: Piecewise((1, Eq(i + 2, j)), (0, True))) Matrix([ [0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]) >>> Matrix(5,5,lambda i,j: Piecewise((1, Eq(i - 2, j)), (0, True))) Matrix([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [1, 0, 0, 0, 0], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0]]) >>> Matrix(5,5,lambda i,j: Piecewise((1, Eq(5-1,i+j+2)),(0,True))) Matrix([ [0, 0, 1, 0, 0], [0, 1, 0, 0, 0], [1, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]) >>> Matrix(5,5,lambda i,j: Piecewise((1, Eq(5-1,i+j-2)),(0,True))) Matrix([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 1], [0, 0, 0, 1, 0], [0, 0, 1, 0, 0]]) ``` ---------- I'm working on this. -------------------- </issues>	c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-16439	16,439	sympy/sympy	1.5	3729e1ba5a2afcfc3ceee7b98b07d5b57303f919	2019-03-25T17:57:37Z	diff --git a/sympy/physics/continuum_mechanics/beam.py b/sympy/physics/continuum_mechanics/beam.py index f4bca0cd9411..80c7b9adcc9b 100644 --- a/sympy/physics/continuum_mechanics/beam.py +++ b/sympy/physics/continuum_mechanics/beam.py @@ -13,6 +13,16 @@ from sympy.integrals import integrate from sympy.series import limit from sympy.plotting import plot, PlotGrid +from sympy.external import import_module +from sympy.utilities.decorator import doctest_depends_on +from sympy import lambdify +from sympy.core.compatibility import iterable + +matplotlib = import_module('matplotlib', __import__kwargs={'fromlist':['pyplot']}) +numpy = import_module('numpy', __import__kwargs={'fromlist':['linspace']}) + +__doctest_requires__ = {('Beam.plot_loading_results',): ['matplotlib']} + class Beam(object): """ @@ -1645,6 +1655,29 @@ def boundary_conditions(self): """ return self._boundary_conditions + def polar_moment(self): + """ + Returns the polar moment of area of the beam + about the X axis with respect to the centroid. + + Examples + ======== + + >>> from sympy.physics.continuum_mechanics.beam import Beam3D + >>> from sympy import symbols + >>> l, E, G, I, A = symbols('l, E, G, I, A') + >>> b = Beam3D(l, E, G, I, A) + >>> b.polar_moment() + 2I + >>> I1 = [9, 15] + >>> b = Beam3D(l, E, G, I1, A) + >>> b.polar_moment() + 24 + """ + if not iterable(self.second_moment): + return 2self.second_moment + return sum(self.second_moment) + def apply_load(self, value, start, order, dir="y"): """ This method adds up the force load to a particular beam object.	diff --git a/sympy/physics/continuum_mechanics/tests/test_beam.py b/sympy/physics/continuum_mechanics/tests/test_beam.py index 980bcb1d76ef..5299ce7c98c9 100644 --- a/sympy/physics/continuum_mechanics/tests/test_beam.py +++ b/sympy/physics/continuum_mechanics/tests/test_beam.py @@ -501,6 +501,7 @@ def test_Beam3D(): b.bc_deflection = [(0, [0, 0, 0]), (l, [0, 0, 0])] b.solve_slope_deflection() + assert b.polar_moment() == 2I assert b.shear_force() == [0, -qx, 0] assert b.bending_moment() == [0, 0, -mx + qx*2/2] expected_deflection = (x(AGqx3/4 + AGx2(-l(AGl(lq - 2m) + @@ -540,6 +541,14 @@ def test_Beam3D(): assert b3.reaction_loads == {R1: -120, R2: -120, R3: -1350, R4: -2700} +def test_polar_moment_Beam3D(): + l, E, G, A, I1, I2 = symbols('l, E, G, A, I1, I2') + I = [I1, I2] + + b = Beam3D(l, E, G, I, A) + assert b.polar_moment() == I1 + I2 + + def test_parabolic_loads(): E, I, L = symbols('E, I, L', positive=True, real=True)		[ { "components": [ { "doc": "Returns the polar moment of area of the beam\nabout the X axis with respect to the centroid.\n\nExamples\n========\n\n>>> from sympy.physics.continuum_mechanics.beam import Beam3D\n>>> from sympy import symbols\n>>> l, E, G, I, A = symbols('l, E, G, I, A')\n>>> b = Beam...	[ "test_Beam3D", "test_polar_moment_Beam3D" ]	[ "test_Beam", "test_insufficient_bconditions", "test_statically_indeterminate", "test_beam_units", "test_variable_moment", "test_composite_beam", "test_point_cflexure", "test_remove_load", "test_apply_support", "test_max_shear_force", "test_max_bmoment", "test_max_deflection" ]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Function to calculate Polar moment of inertia of a 3D Beam <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> fixes #16392 #### Brief description of what is fixed or changed New function in Beam/Beam3D #### Other comments Currently calculates polar moment only along x-axis #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * physics.continuum_mechanics * added a new function polar_moment() <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/physics/continuum_mechanics/beam.py] (definition of Beam3D.polar_moment:) def polar_moment(self): """Returns the polar moment of area of the beam about the X axis with respect to the centroid. Examples ======== >>> from sympy.physics.continuum_mechanics.beam import Beam3D >>> from sympy import symbols >>> l, E, G, I, A = symbols('l, E, G, I, A') >>> b = Beam3D(l, E, G, I, A) >>> b.polar_moment() 2*I >>> I1 = [9, 15] >>> b = Beam3D(l, E, G, I1, A) >>> b.polar_moment() 24""" [end of new definitions in sympy/physics/continuum_mechanics/beam.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> No function for calculating polar moment of inertia and section modulus in continuum_mechanics in beam.py There is currently no function to calculate polar moment of inertia and section modulus of the beam . Both of these quantities are important in further future works in this module. ---------- Can I work on this? Sure, feel free. Here the Beam is 2D, so along what axis should the polar moment be? Usually it is along the beam, right? @arooshiverma There is a separate class for 3D beams. Checkout from line no 1493. I think you'll have to calculate it in all 3 directions. Yeah got it. Will do it. -------------------- </issues>	c72f122f67553e1af930bac6c35732d2a0bbb776
sympy__sympy-16423	16,423	sympy/sympy	1.5	815be53c35580e119f864466095fb1d7ecd65f4f	2019-03-24T15:14:21Z	diff --git a/sympy/physics/quantum/commutator.py b/sympy/physics/quantum/commutator.py index 487dc923e9f5..94cd53a1f245 100644 --- a/sympy/physics/quantum/commutator.py +++ b/sympy/physics/quantum/commutator.py @@ -2,7 +2,7 @@ from __future__ import print_function, division -from sympy import S, Expr, Mul, Add +from sympy import S, Expr, Mul, Add, Pow from sympy.printing.pretty.stringpict import prettyForm from sympy.physics.quantum.dagger import Dagger @@ -117,6 +117,22 @@ def eval(cls, a, b): if a.compare(b) == 1: return S.NegativeOnecls(b, a) + def _expand_pow(self, A, B, sign): + exp = A.exp + if not exp.is_integer or not exp.is_constant() or abs(exp) <= 1: + # nothing to do + return self + base = A.base + if exp.is_negative: + base = A.base-1 + exp = -exp + comm = Commutator(base, B).expand(commutator=True) + + result = base(exp - 1) comm + for i in range(1, exp): + result += base*(exp - 1 - i) comm * base*i + return signresult.expand() + def _eval_expand_commutator(self, hints): A = self.args[0] B = self.args[1] @@ -167,6 +183,12 @@ def _eval_expand_commutator(self, hints): first = Mul(comm1, c) second = Mul(b, comm2) return Add(first, second) + elif isinstance(A, Pow): + # [An, C] -> A(n - 1)[A, C] + A(n - 2)[A, C]A + ... + [A, C]A(n-1) + return self._expand_pow(A, B, 1) + elif isinstance(B, Pow): + # [A, Cn] -> C*(n - 1)[C, A] + C*(n - 2)[C, A]C + ... + [C, A]C**(n-1) + return self._expand_pow(B, A, -1) # No changes, so return self return self	diff --git a/sympy/physics/quantum/tests/test_commutator.py b/sympy/physics/quantum/tests/test_commutator.py index 021698740e04..a8aa1589b753 100644 --- a/sympy/physics/quantum/tests/test_commutator.py +++ b/sympy/physics/quantum/tests/test_commutator.py @@ -6,6 +6,7 @@ a, b, c = symbols('a,b,c') +n = symbols('n', integer=True) A, B, C, D = symbols('A,B,C,D', commutative=False) @@ -25,9 +26,17 @@ def test_commutator_identities(): assert Comm(A, BC).expand(commutator=True) == Comm(A, B)C + BComm(A, C) assert Comm(AB, CD).expand(commutator=True) == \ ACComm(B, D) + AComm(B, C)D + CComm(A, D)B + Comm(A, C)DB + assert Comm(A, B2).expand(commutator=True) == Comm(A, B)B + BComm(A, B) + assert Comm(A2, C2).expand(commutator=True) == \ + Comm(AB, CD).expand(commutator=True).replace(B, A).replace(D, C) == \ + ACComm(A, C) + AComm(A, C)C + CComm(A, C)A + Comm(A, C)CA + assert Comm(A, C-2).expand(commutator=True) == \ + Comm(A, (1/C)(1/D)).expand(commutator=True).replace(D, C) assert Comm(A + B, C + D).expand(commutator=True) == \ Comm(A, C) + Comm(A, D) + Comm(B, C) + Comm(B, D) assert Comm(A, B + C).expand(commutator=True) == Comm(A, B) + Comm(A, C) + assert Comm(An, B).expand(commutator=True) == Comm(An, B) + e = Comm(A, Comm(B, C)) + Comm(B, Comm(C, A)) + Comm(C, Comm(A, B)) assert e.doit().expand() == 0 @@ -64,3 +73,8 @@ def test_eval_commutator(): assert Comm(F, T).doit() == -1 assert Comm(T, F).doit() == 1 assert Comm(B, T).doit() == BT - TB + assert Comm(F2, B).expand(commutator=True).doit() == 0 + assert Comm(F2, T).expand(commutator=True).doit() == -2F + assert Comm(F, T2).expand(commutator=True).doit() == -2T + assert Comm(T*2, F).expand(commutator=True).doit() == 2T + assert Comm(T2, F3).expand(commutator=True).doit() == 2FTF + 2F*2T + 2TF**2		[ { "components": [ { "doc": "", "lines": [ 120, 134 ], "name": "Commutator._expand_pow", "signature": "def _expand_pow(self, A, B, sign):", "type": "function" } ], "file": "sympy/physics/quantum/commutator.py" } ]	[ "test_commutator_identities" ]	[ "test_commutator", "test_commutator_dagger" ]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Handle Pow in Commutator expansion. #### Brief description of what is fixed or changed Handle expansion of commutators like ``` [A*2, C] = [AA, C] -> A[A, C] + [A, C]A ``` but for arbitrary integer exponent. #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * physics.quantum * Pow expressions handled in Commutator expansion <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/physics/quantum/commutator.py] (definition of Commutator._expand_pow:) def _expand_pow(self, A, B, sign): [end of new definitions in sympy/physics/quantum/commutator.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c72f122f67553e1af930bac6c35732d2a0bbb776
astropy__astropy-8517	8,517	astropy/astropy	3.1	cfe7616626c00c3dc7a912c1f432c00d52dba8b0	2019-03-21T16:49:54Z	diff --git a/CHANGES.rst b/CHANGES.rst index 9cc0c28c2d96..5d5bf3f541a2 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -10,6 +10,9 @@ astropy.config astropy.constants ^^^^^^^^^^^^^^^^^ +- The version of constants can be specified via ScienceState in a way + that ``constants`` and ``units`` will be consistent. [#8517] + astropy.convolution ^^^^^^^^^^^^^^^^^^^ diff --git a/astropy/__init__.py b/astropy/__init__.py index ab8d1736ad27..edfea0da948d 100644 --- a/astropy/__init__.py +++ b/astropy/__init__.py @@ -157,6 +157,80 @@ class Conf(_config.ConfigNamespace): conf = Conf() + +# Define a base ScienceState for configuring constants and units +from .utils.state import ScienceState +class base_constants_version(ScienceState): + """ + Base class for the real version-setters below + """ + _value = 'test' + + _versions = dict(test='test') + + @classmethod + def validate(cls, value): + if value not in cls._versions: + raise ValueError('Must be one of {}' + .format(list(cls._versions.keys()))) + return cls._versions[value] + + @classmethod + def set(cls, value): + """ + Set the current constants value. + """ + import sys + if 'astropy.units' in sys.modules: + raise RuntimeError('astropy.units is already imported') + if 'astropy.constants' in sys.modules: + raise RuntimeError('astropy.constants is already imported') + + class _Context: + def __init__(self, parent, value): + self._value = value + self._parent = parent + + def __enter__(self): + pass + + def __exit__(self, type, value, tb): + self._parent._value = self._value + + def __repr__(self): + return ('<ScienceState {0}: {1!r}>' + .format(self._parent.__name__, self._parent._value)) + + ctx = _Context(cls, cls._value) + value = cls.validate(value) + cls._value = value + return ctx + + +class physical_constants(base_constants_version): + """ + The version of physical constants to use + """ + # Maintainers: update when new constants are added + _value = 'codata2014' + + _versions = dict(codata2018='codata2018', codata2014='codata2014', + codata2010='codata2010', astropyconst40='codata2018', + astropyconst20='codata2014', astropyconst13='codata2010') + + +class astronomical_constants(base_constants_version): + """ + The version of astronomical constants to use + """ + # Maintainers: update when new constants are added + _value = 'iau2015' + + _versions = dict(iau2015='iau2015', iau2012='iau2012', + astropyconst40='iau2015', astropyconst20='iau2015', + astropyconst13='iau2012') + + # Create the test() function from .tests.runner import TestRunner test = TestRunner.make_test_runner_in(__path__[0]) @@ -320,7 +394,8 @@ def online_help(query): __dir_inc__ = ['__version__', '__githash__', '__minimum_numpy_version__', '__bibtex__', 'test', 'log', 'find_api_page', 'online_help', - 'online_docs_root', 'conf'] + 'online_docs_root', 'conf', 'physical_constants', + 'astronomical_constants'] from types import ModuleType as __module_type__ diff --git a/astropy/constants/__init__.py b/astropy/constants/__init__.py index 65350120f9d9..7607e642de77 100644 --- a/astropy/constants/__init__.py +++ b/astropy/constants/__init__.py @@ -13,21 +13,21 @@ <Quantity 0.510998927603161 MeV> """ +import warnings from contextlib import contextmanager from astropy.utils import find_current_module # Hack to make circular imports with units work -try: - from astropy import units - del units -except ImportError: - pass +from astropy import units +del units +# These lines import some namespaces into the top level from .constant import Constant, EMConstant # noqa from . import si # noqa from . import cgs # noqa -from . import codata2014, iau2015 # noqa +from .config import codata, iaudata + from . import utils as _utils # for updating the constants module docstring @@ -38,9 +38,11 @@ '========== ============== ================ =========================', ] -# NOTE: Update this when default changes. -_utils._set_c(codata2014, iau2015, find_current_module(), - not_in_module_only=True, doclines=_lines, set_class=True) +# Catch warnings about "already has a definition in the None system" +with warnings.catch_warnings(): + warnings.filterwarnings('ignore', 'Constant .already has a definition') + _utils._set_c(codata, iaudata, find_current_module(), + not_in_module_only=False, doclines=_lines, set_class=True) _lines.append(_lines[1]) @@ -65,38 +67,42 @@ def set_enabled_constants(modname): """ # Re-import here because these were deleted from namespace on init. + import importlib import warnings from astropy.utils import find_current_module from . import utils as _utils - # NOTE: Update this when default changes. - if modname == 'astropyconst13': - from .astropyconst13 import codata2010 as codata - from .astropyconst13 import iau2012 as iaudata - else: - raise ValueError( - 'Context manager does not currently handle {}'.format(modname)) + try: + modmodule = importlib.import_module('.constants.' + modname, 'astropy') + codata_context = modmodule.codata + iaudata_context = modmodule.iaudata + except ImportError as exc: + exc.args += ('Context manager does not currently handle {}' + .format(modname),) + raise module = find_current_module() # Ignore warnings about "Constant xxx already has a definition..." with warnings.catch_warnings(): - warnings.simplefilter('ignore') - _utils._set_c(codata, iaudata, module, + warnings.filterwarnings('ignore', + 'Constant .already has a definition') + _utils._set_c(codata_context, iaudata_context, module, not_in_module_only=False, set_class=True) try: yield finally: with warnings.catch_warnings(): - warnings.simplefilter('ignore') - # NOTE: Update this when default changes. - _utils._set_c(codata2014, iau2015, module, + warnings.filterwarnings('ignore', + 'Constant .already has a definition') + _utils._set_c(codata, iaudata, module, not_in_module_only=False, set_class=True) # Clean up namespace del find_current_module +del warnings del contextmanager del _utils del _lines diff --git a/astropy/constants/astropyconst13.py b/astropy/constants/astropyconst13.py index 4e19a0f883d5..b22fca4ccd67 100644 --- a/astropy/constants/astropyconst13.py +++ b/astropy/constants/astropyconst13.py @@ -8,7 +8,10 @@ from . import utils as _utils from . import codata2010, iau2012 -_utils._set_c(codata2010, iau2012, find_current_module()) +codata = codata2010 +iaudata = iau2012 + +_utils._set_c(codata, iaudata, find_current_module()) # Clean up namespace del find_current_module diff --git a/astropy/constants/astropyconst20.py b/astropy/constants/astropyconst20.py index 5a04ec7d6196..050db5d0af16 100644 --- a/astropy/constants/astropyconst20.py +++ b/astropy/constants/astropyconst20.py @@ -7,7 +7,11 @@ from . import utils as _utils from . import codata2014, iau2015 -_utils._set_c(codata2014, iau2015, find_current_module()) + +codata = codata2014 +iaudata = iau2015 + +_utils._set_c(codata, iaudata, find_current_module()) # Clean up namespace del find_current_module diff --git a/astropy/constants/cgs.py b/astropy/constants/cgs.py index adca1b3411c3..0c7aeb536765 100644 --- a/astropy/constants/cgs.py +++ b/astropy/constants/cgs.py @@ -3,14 +3,13 @@ Astronomical and physics constants in cgs units. See :mod:`astropy.constants` for a complete listing of constants defined in Astropy. """ - import itertools from .constant import Constant -from . import codata2014, iau2015 +from .config import codata, iaudata -for _nm, _c in itertools.chain(sorted(vars(codata2014).items()), - sorted(vars(iau2015).items())): +for _nm, _c in itertools.chain(sorted(vars(codata).items()), + sorted(vars(iaudata).items())): if (isinstance(_c, Constant) and _c.abbrev not in locals() - and _c.system in ['esu', 'gauss', 'emu']): + and _c.system in ['esu', 'gauss', 'emu']): locals()[_c.abbrev] = _c diff --git a/astropy/constants/config.py b/astropy/constants/config.py new file mode 100644 index 000000000000..c163b820ec98 --- /dev/null +++ b/astropy/constants/config.py @@ -0,0 +1,14 @@ +# Licensed under a 3-clause BSD style license - see LICENSE.rst +""" +Configures the codata and iaudata used, possibly using user configuration. +""" +# Note: doing this in __init__ causes import problems with units, +# as si.py and cgs.py have to import the result. +import importlib +import astropy + +phys_version = astropy.physical_constants.get() +astro_version = astropy.astronomical_constants.get() + +codata = importlib.import_module('.constants.' + phys_version, 'astropy') +iaudata = importlib.import_module('.constants.' + astro_version, 'astropy') diff --git a/astropy/constants/si.py b/astropy/constants/si.py index 65e5a2d13eb8..c8f83a841110 100644 --- a/astropy/constants/si.py +++ b/astropy/constants/si.py @@ -3,16 +3,13 @@ Astronomical and physics constants in SI units. See :mod:`astropy.constants` for a complete listing of constants defined in Astropy. """ - - - import itertools from .constant import Constant -from . import codata2014, iau2015 +from .config import codata, iaudata -for _nm, _c in itertools.chain(sorted(vars(codata2014).items()), - sorted(vars(iau2015).items())): +for _nm, _c in itertools.chain(sorted(vars(codata).items()), + sorted(vars(iaudata).items())): if (isinstance(_c, Constant) and _c.abbrev not in locals() - and _c.system == 'si'): + and _c.system == 'si'): locals()[_c.abbrev] = _c diff --git a/docs/constants/index.rst b/docs/constants/index.rst index de4e4709f299..d31aa1656a40 100644 --- a/docs/constants/index.rst +++ b/docs/constants/index.rst @@ -118,9 +118,57 @@ Union (IAU) are collected in modules with names like ``iau2012`` or ``iau2015``: Reference = IAU 2015 Resolution B 3 The astronomical and physical constants are combined into modules with -names like ``astropyconst13`` and ``astropyconst20``. To temporarily set -constants to an older version (e.g., for regression testing), a context -manager is available as follows: +names like ``astropyconst13`` and ``astropyconst20`` for different versions. +However, importing these prior version modules directly will lead to +inconsistencies with other subpackages that have already imported +`astropy.constants`. Notably, `astropy.units` will have already used +the default version of constants. When using prior versions of the constants +in this manner, quantities should be constructed with constants instead of units. + +To ensure consistent use of a prior version of constants in other Astropy +packages (such as `astropy.units`) that import constants, the physical and +astronomical constants versions should be set via ScienceState classes. +These must be set before the first import of either `astropy.constants` or +`astropy.units`. For example, you can use the CODATA2010 physical constants and the +IAU 2012 astronomical constants: + + >>> from astropy import physical_constants, astronomical_constants + >>> physical_constants.set('codata2010') # doctest: +SKIP + <ScienceState physical_constants: 'codata2010'> + >>> physical_constants.get() # doctest: +SKIP + 'codata2010' + >>> astronomical_constants.set('iau2012') # doctest: +SKIP + <ScienceState astronomical_constants: 'iau2012'> + >>> astronomical_constants.get() # doctest: +SKIP + 'iau2012' + +Then all other packages that import `astropy.constants` will self-consistently +initialize with that prior version of constants. + +The versions may also be set using values referring to the version modules: + + >>> from astropy import physical_constants, astronomical_constants + >>> physical_constants.set('astropyconst13') # doctest: +SKIP + <ScienceState physical_constants: 'codata2010'> + >>> physical_constants.get() # doctest: +SKIP + 'codata2010' + >>> astronomical_constants.set('astropyconst13') # doctest: +SKIP + <ScienceState astronomical_constants: 'iau2012'> + >>> astronomical_constants.get() # doctest: +SKIP + 'iau2012' + +If either `astropy.constants` or `astropy.units` have already been imported, a +``RuntimeError`` will be raised. + + >>> import astropy.units + >>> from astropy import physical_constants, astronomical_constants + >>> astronomical_constants.set('astropyconst13') + Traceback (most recent call last): + ... + RuntimeError: astropy.units is already imported + +To temporarily set constants to an older version (e.g., +for regression testing), a context manager is available, as follows: >>> from astropy import constants as const >>> with const.set_enabled_constants('astropyconst13'): @@ -137,11 +185,10 @@ manager is available as follows: Unit = J s Reference = CODATA 2014 -.. warning:: +The context manager may be used at any time in a Python session, but it +uses the prior version only for `astropy.constants`, and not for any +other subpackage such as `astropy.units`. - Units such as ``u.M_sun`` will use the current version of the - corresponding constant. When using prior versions of the constants, - quantities should be constructed with constants instead of units. .. note that if this section gets too long, it should be moved to a separate doc page - see the top of performance.inc.rst for the instructions on how to diff --git a/docs/units/constants_versions.rst b/docs/units/constants_versions.rst new file mode 100644 index 000000000000..4663b3257f24 --- /dev/null +++ b/docs/units/constants_versions.rst @@ -0,0 +1,29 @@ +Using prior versions of constants +******************************** + +By default, `astropy.units` are initialized upon first import to use +the current versions of `astropy.constants`. For units to initialize +properly to a prior version of constants, the constants versions must +be set before the first import of `astropy.units` or `astropy.constants`. + +This is accomplished using ScienceState classes in the top-level package. +Setting the prior versions at the start of a Python session will allow +consistent units, as follows: + +>>> import astropy +>>> astropy.physical_constants.set('codata2010') # doctest: +SKIP +<ScienceState physical_constants: 'codata2010'> +>>> astropy.astronomical_constants.set('iau2012') # doctest: +SKIP +<ScienceState astronomical_constants: 'iau2012'> +>>> import astropy.units as u +>>> import astropy.constants as const +>>> (const.M_sun / u.M_sun).to(u.dimensionless_unscaled) - 1 # doctest: +SKIP +<Quantity 0.> +>>> const.M_sun # doctest: +SKIP + Name = Solar mass + Value = 1.9891e+30 + Uncertainty = 5e+25 + Unit = kg + Reference = Allen's Astrophysical Quantities 4th Ed. + +If `astropy.units` has already been imported, a RuntimeError is raised. diff --git a/docs/units/index.rst b/docs/units/index.rst index 4267de423490..82a7d412d664 100644 --- a/docs/units/index.rst +++ b/docs/units/index.rst @@ -165,6 +165,7 @@ Using `astropy.units` logarithmic_units format equivalencies + constants_versions conversion See Also	diff --git a/astropy/constants/tests/test_prior_version.py b/astropy/constants/tests/test_prior_version.py index 5d13c66a7b98..c7f54ef75b60 100644 --- a/astropy/constants/tests/test_prior_version.py +++ b/astropy/constants/tests/test_prior_version.py @@ -163,6 +163,6 @@ def test_context_manager(): assert const.h.value == 6.626070040e-34 # CODATA2014 - with pytest.raises(ValueError): + with pytest.raises(ImportError): with const.set_enabled_constants('notreal'): const.h diff --git a/astropy/constants/tests/test_sciencestate.py b/astropy/constants/tests/test_sciencestate.py new file mode 100644 index 000000000000..1fa32b6909e1 --- /dev/null +++ b/astropy/constants/tests/test_sciencestate.py @@ -0,0 +1,21 @@ +import pytest + +from astropy import physical_constants, astronomical_constants +import astropy.constants as const + + +def test_version_match(): + pversion = physical_constants.get() + refpversion = const.h.__class__.__name__.lower() + assert pversion == refpversion + aversion = astronomical_constants.get() + refaversion = const.M_sun.__class__.__name__.lower() + assert aversion == refaversion + + +def test_previously_imported(): + with pytest.raises(RuntimeError): + physical_constants.set('codata2018') + + with pytest.raises(RuntimeError): + astronomical_constants.set('iau2015')	diff --git a/CHANGES.rst b/CHANGES.rst index 9cc0c28c2d96..5d5bf3f541a2 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -10,6 +10,9 @@ astropy.config astropy.constants ^^^^^^^^^^^^^^^^^ +- The version of constants can be specified via ScienceState in a way + that ``constants`` and ``units`` will be consistent. [#8517] + astropy.convolution ^^^^^^^^^^^^^^^^^^^ diff --git a/docs/constants/index.rst b/docs/constants/index.rst index de4e4709f299..d31aa1656a40 100644 --- a/docs/constants/index.rst +++ b/docs/constants/index.rst @@ -118,9 +118,57 @@ Union (IAU) are collected in modules with names like ``iau2012`` or ``iau2015``: Reference = IAU 2015 Resolution B 3 The astronomical and physical constants are combined into modules with -names like ``astropyconst13`` and ``astropyconst20``. To temporarily set -constants to an older version (e.g., for regression testing), a context -manager is available as follows: +names like ``astropyconst13`` and ``astropyconst20`` for different versions. +However, importing these prior version modules directly will lead to +inconsistencies with other subpackages that have already imported +`astropy.constants`. Notably, `astropy.units` will have already used +the default version of constants. When using prior versions of the constants +in this manner, quantities should be constructed with constants instead of units. + +To ensure consistent use of a prior version of constants in other Astropy +packages (such as `astropy.units`) that import constants, the physical and +astronomical constants versions should be set via ScienceState classes. +These must be set before the first import of either `astropy.constants` or +`astropy.units`. For example, you can use the CODATA2010 physical constants and the +IAU 2012 astronomical constants: + + >>> from astropy import physical_constants, astronomical_constants + >>> physical_constants.set('codata2010') # doctest: +SKIP + <ScienceState physical_constants: 'codata2010'> + >>> physical_constants.get() # doctest: +SKIP + 'codata2010' + >>> astronomical_constants.set('iau2012') # doctest: +SKIP + <ScienceState astronomical_constants: 'iau2012'> + >>> astronomical_constants.get() # doctest: +SKIP + 'iau2012' + +Then all other packages that import `astropy.constants` will self-consistently +initialize with that prior version of constants. + +The versions may also be set using values referring to the version modules: + + >>> from astropy import physical_constants, astronomical_constants + >>> physical_constants.set('astropyconst13') # doctest: +SKIP + <ScienceState physical_constants: 'codata2010'> + >>> physical_constants.get() # doctest: +SKIP + 'codata2010' + >>> astronomical_constants.set('astropyconst13') # doctest: +SKIP + <ScienceState astronomical_constants: 'iau2012'> + >>> astronomical_constants.get() # doctest: +SKIP + 'iau2012' + +If either `astropy.constants` or `astropy.units` have already been imported, a +``RuntimeError`` will be raised. + + >>> import astropy.units + >>> from astropy import physical_constants, astronomical_constants + >>> astronomical_constants.set('astropyconst13') + Traceback (most recent call last): + ... + RuntimeError: astropy.units is already imported + +To temporarily set constants to an older version (e.g., +for regression testing), a context manager is available, as follows: >>> from astropy import constants as const >>> with const.set_enabled_constants('astropyconst13'): @@ -137,11 +185,10 @@ manager is available as follows: Unit = J s Reference = CODATA 2014 -.. warning:: +The context manager may be used at any time in a Python session, but it +uses the prior version only for `astropy.constants`, and not for any +other subpackage such as `astropy.units`. - Units such as ``u.M_sun`` will use the current version of the - corresponding constant. When using prior versions of the constants, - quantities should be constructed with constants instead of units. .. note that if this section gets too long, it should be moved to a separate doc page - see the top of performance.inc.rst for the instructions on how to diff --git a/docs/units/constants_versions.rst b/docs/units/constants_versions.rst new file mode 100644 index 000000000000..4663b3257f24 --- /dev/null +++ b/docs/units/constants_versions.rst @@ -0,0 +1,29 @@ +Using prior versions of constants +********************************* + +By default, `astropy.units` are initialized upon first import to use +the current versions of `astropy.constants`. For units to initialize +properly to a prior version of constants, the constants versions must +be set before the first import of `astropy.units` or `astropy.constants`. + +This is accomplished using ScienceState classes in the top-level package. +Setting the prior versions at the start of a Python session will allow +consistent units, as follows: + +>>> import astropy +>>> astropy.physical_constants.set('codata2010') # doctest: +SKIP +<ScienceState physical_constants: 'codata2010'> +>>> astropy.astronomical_constants.set('iau2012') # doctest: +SKIP +<ScienceState astronomical_constants: 'iau2012'> +>>> import astropy.units as u +>>> import astropy.constants as const +>>> (const.M_sun / u.M_sun).to(u.dimensionless_unscaled) - 1 # doctest: +SKIP +<Quantity 0.> +>>> const.M_sun # doctest: +SKIP + Name = Solar mass + Value = 1.9891e+30 + Uncertainty = 5e+25 + Unit = kg + Reference = Allen's Astrophysical Quantities 4th Ed. + +If `astropy.units` has already been imported, a RuntimeError is raised. diff --git a/docs/units/index.rst b/docs/units/index.rst index 4267de423490..82a7d412d664 100644 --- a/docs/units/index.rst +++ b/docs/units/index.rst @@ -165,6 +165,7 @@ Using `astropy.units` logarithmic_units format equivalencies + constants_versions conversion See Also	[ { "components": [ { "doc": "Base class for the real version-setters below", "lines": [ 163, 207 ], "name": "base_constants_version", "signature": "class base_constants_version(ScienceState):", "type": "class" }, { "doc...	[ "astropy/constants/tests/test_prior_version.py::test_c", "astropy/constants/tests/test_prior_version.py::test_h", "astropy/constants/tests/test_prior_version.py::test_e", "astropy/constants/tests/test_prior_version.py::test_g0", "astropy/constants/tests/test_prior_version.py::test_b_wien", "astropy/consta...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Set constants version via ScienceState classes Fixes #6948 Add ScienceState classes for `astropy.constants` versions, to allow a user to set constants versions before importing units or constants. Then when the user does `import astropy.units as u`, the user-specified versions of constants will initialize units. EDIT: removed "work in progress" warnings EDIT: renamed to use ScienceState instead of config files ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in astropy/__init__.py] (definition of base_constants_version:) class base_constants_version(ScienceState): """Base class for the real version-setters below""" (definition of base_constants_version.validate:) def validate(cls, value): (definition of base_constants_version.set:) def set(cls, value): """Set the current constants value.""" (definition of base_constants_version.set._Context:) class _Context: (definition of base_constants_version.set._Context.__init__:) def __init__(self, parent, value): (definition of base_constants_version.set._Context.__enter__:) def __enter__(self): (definition of base_constants_version.set._Context.__exit__:) def __exit__(self, type, value, tb): (definition of base_constants_version.set._Context.__repr__:) def __repr__(self): (definition of physical_constants:) class physical_constants(base_constants_version): """The version of physical constants to use""" (definition of astronomical_constants:) class astronomical_constants(base_constants_version): """The version of astronomical constants to use""" [end of new definitions in astropy/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Make units be consistent with versioned constants This motivation for this issue is fixing a subtle but important inconsistency that can now appear because constants are versioned (new feature in v2.0). The basic problem is that some units are effectively tied to constants. For example `units.solMass` exists, but so does `constants.M_sun`. Right now with the default units they are consistent, but if someone uses the constant versioning machinery to update e.g. M_sun, they become inconsistent. There are a couple possible fixes here: * Tie the units to the constant values so that if a particular constant is set as the "current" version, the unit is assumed to have that value (I think that is more "right" but probably requires subtle and/or major changes to `units`). * Make unit conversion factors versionable, and provide helper functions or just instructions for how to sync them up (possibly easier, but means manual intervention is required). ---------- This is somewhat tricky, as unit definitions cascade down - one would effectively need the ability to reload `units` (or whole of astropy?). And of course even before that to reload `constants` itself. It may be easier to have a configuration item that states which constants are loaded by default (now: `codata2014`, `iau2015`). I am going to try the suggestion from @mhvk to make a configuration item for the versions of constants that are loaded when `units` or `constants` are first imported. Shooting for 3.2 which means having a PR open by April 5th, 2019. -------------------- </issues>	12a4d64093b833e198b2736d3cff817a9b286efc
joke2k__faker-930	930	joke2k/faker	null	eb7d9c838cd297c70730c43f2728ce86fe7320d9	2019-03-20T16:04:43Z	diff --git a/faker/providers/company/nl_NL/__init__.py b/faker/providers/company/nl_NL/__init__.py new file mode 100644 index 0000000000..6799303495 --- /dev/null +++ b/faker/providers/company/nl_NL/__init__.py @@ -0,0 +1,109 @@ +# coding=utf-8 + +from __future__ import unicode_literals +from .. import Provider as CompanyProvider + + +class Provider(CompanyProvider): + + formats = ( + '{{last_name}} {{company_suffix}}', + '{{last_name}} & {{last_name}}', + '{{company_prefix}} {{last_name}}', + '{{large_company}}', + ) + + company_prefixes = ( + 'Stichting', 'Koninklijke', 'Royal', + ) + + company_suffixes = ( + 'BV', 'NV', 'Groep', + ) + + # Source: https://www.mt.nl/management/reputatie/mt-500-2018-de-lijst/559930 + large_companies = ( + 'Shell', 'Coolblue', 'ASML', 'Ahold', 'Tata Steel', 'KLM', 'Bol.com', 'BP Nederland', 'De Efteling', 'Eneco', + 'De Persgroep', 'ING', 'Royal HaskoningDHV', 'Randstad', 'Google', 'Ikea', 'Rockwool', 'BAM', 'Achmea', + 'Damen Shipyard', 'ABN Amro', 'Remeha Group', 'TenneT', 'Coca-Cola', 'Van Leeuwen Buizen', 'Wavin', 'Rabobank', + 'AkzoNobel', 'Arcadis', 'AFAS', 'Cisco', 'DAF Trucks', 'DHL', 'Hanos', 'Boon Edam', 'BMW Nederland', + 'The Greenery', 'Dutch Flower Group', 'Koninklijke Mosa', 'Yacht', 'Rituals', 'Microsoft', 'Esso', + '3W Vastgoed', 'Deloitte', 'Corio', 'Voortman Steel Group', 'Agrifirm', 'Makro Nederland', + 'Nederlandse Publieke Omroep', 'De Alliantie', 'Heijmans', 'McDonalds', 'ANWB', 'Mediamarkt', 'Kruidvat' + 'Van Merksteijn Steel', 'Dura Vermeer', 'Alliander', 'Unilever', 'Enexis', 'Berenschot', 'Jumbo', + 'Technische Unie', 'Havenbedrijf Rotterdam', 'Ballast Nedam', 'RTL Nederland', 'Talpa Media', + 'Blauwhoed Vastgoed', 'DSM', 'Ymere', 'Witteveen+Bos', 'NS', 'Action', 'FloraHolland', 'Heineken', 'Nuon', 'EY', + 'Dow Benelux', 'Bavaria', 'Schiphol', 'Holland Casino', 'Binck bank', 'BDO', 'HEMA', 'Alphabet Nederland', + 'Croon Elektrotechniek', 'ASR Vastgoed ontwikkeling', 'PwC', 'Mammoet', 'KEMA', 'IBM', 'A.S. Watson', + 'KPMG', 'VodafoneZiggo', 'YoungCapital', 'Triodos Bank', 'Aviko', 'AgruniekRijnvallei', 'Heerema', 'Accenture', + 'Aegon', 'NXP', 'Breman Installatiegroep', 'Movares Groep', 'Q-Park', 'FleuraMetz', 'Sanoma', + 'Bakker Logistiek', 'VDL Group', 'Bayer', 'Boskalis', 'Nutreco', 'Dell', 'Brunel', 'Exact', 'Manpower', + 'Essent', 'Canon', 'ONVZ Zorgverzekeraar', 'Telegraaf Media Group', 'Nationale Nederlanden', 'Andus Group', + 'Den Braven Group', 'ADP', 'ASR', 'ArboNed', 'Plieger', 'De Heus Diervoeders', 'USG People', 'Bidvest Deli XL', + 'Apollo Vredestein', 'Tempo-Team', 'Trespa', 'Janssen Biologics', 'Starbucks', 'PostNL', 'Vanderlande', + 'FrieslandCampina', 'Constellium', 'Huisman', 'Abbott', 'Koninklijke Boom Uitgevers', 'Bosch Rexroth', 'BASF', + 'Audax', 'VolkerWessels', 'Hunkemöller', 'Athlon Car Lease', 'DSW Zorgverzekeraar', 'Mars', + 'De Brauw Blackstone Westbroek', 'NDC Mediagroep', 'Bluewater', 'Stedin', 'Feenstra', + 'Wuppermann Staal Nederland', 'Kramp', 'SABIC', 'Iv-Groep', 'Bejo Zaden', 'Wolters Kluwer', 'Nyrstar holding', + 'Adecco', 'Tauw', 'Robeco', 'Eriks', 'Allianz Nederland Groep', 'Driessen', 'Burger King', 'Lekkerland', + 'Van Lanschot', 'Brocacef', 'Bureau Veritas', 'Relx', 'Pathé Bioscopen', 'Bosal', + 'Ardagh Group', 'Maandag', 'Inalfa', 'Atradius', 'Capgemini', 'Greenchoice', 'Q8 (Kuwait Petroleum Europe)', + 'ASM International', 'Van der Valk', 'Delta Lloyd', 'GlaxoSmithKline', 'ABB', + 'Fabory, a Grainger company', 'Veen Bosch & Keuning Uitgeversgroep', 'CZ', 'Plus', 'RET Rotterdam', + 'Loyens & Loeff', 'Holland Trading', 'Archer Daniels Midland Nederland', 'Ten Brinke', 'NAM', 'DAS', + 'Samsung Electronics Benelux', 'Koopman International', 'TUI', 'Lannoo Meulenhoff', 'AC Restaurants', + 'Stage Entertainment', 'Acer', 'HDI Global SE', 'Detailresult', 'Nestle', 'GVB Amsterdam', 'Dekamarkt', 'Dirk', + 'MSD', 'Arriva', 'Baker Tilly Berk', 'SBM Offshore', 'TomTom', 'Fujifilm', 'B&S', 'BCC', 'Gasunie', + 'Oracle Nederland', 'Astellas Pharma', 'SKF', 'Woningstichting Eigen Haard', 'Rijk Zwaan', 'Chubb', 'Fugro', + 'Total', 'Rochdale', 'ASVB', 'Atos', 'Acomo', 'KPN', 'Van Drie Group', 'Olympia uitzendbureau', + 'Bacardi Nederland', 'JMW Horeca Uitzendbureau', 'Warner Bros/Eyeworks', 'Aalberts Industries', 'SNS Bank', + 'Amtrada Holding', 'VGZ', 'Grolsch', 'Office Depot', 'De Rijke Group', 'Bovemij Verzekeringsgroep', + 'Coop Nederland', 'Eaton Industries', 'ASN', 'Yara Sluiskil', 'HSF Logistics', 'Fokker', 'Deutsche Bank', + 'Sweco', 'Univé Groep', 'Koninklijke Wagenborg', 'Strukton', 'Conclusion', 'Philips', 'In Person', + 'Fluor', 'Vroegop-Windig', 'ArboUnie', 'Centraal Boekhuis', 'Siemens', 'Connexxion', 'Fujitsu', 'Consolid', + 'AVR Afvalverwerking', 'Brabant Alucast', 'Centric', 'Havensteder', 'Novartis', 'Booking.com', 'Menzis', + 'Frankort & Koning Groep', 'Jan de Rijk', 'Brand Loyalty Group', 'Ohra Verzekeringen', 'Terberg Group', + 'Cloetta', 'Holland & Barrett', 'Enza Zaden', 'VION', 'Woonzorg Nederland', + 'T-Mobile', 'Crucell', 'NautaDutilh', 'BNP Paribas', 'NIBC Bank', 'VastNed', 'CCV Holland', + 'IHC Merwede', 'Neways', 'NSI N.V.', 'Deen', 'Accor', 'HTM', 'ITM Group', 'Ordina', 'Dümmen Orange', 'Optiver', + 'Zara', 'L\'Oreal Nederland B.V.', 'Vinci Energies', 'Suit Supply Topco', 'Sita', 'Vos Logistics', + 'Altran', 'St. Clair', 'BESI', 'Fiat Chrysler Automobiles', 'UPS', 'Jacobs', 'Emté', 'TBI', 'De Bijenkorf', + 'Aldi Nederland', 'Van Wijnen', 'Vitens', 'De Goudse Verzekeringen', 'SBS Broadcasting', + 'Sandd', 'Omron', 'Sogeti', 'Alfa Accountants & Adviseurs', 'Harvey Nash', 'Stork', 'Glencore Grain', + 'Meijburg & Co', 'Honeywell', 'Meyn', 'Ericsson Telecommunicatie', 'Hurks', 'Mitsubishi', 'GGN', + 'CGI Nederland', 'Staples Nederland', 'Denkavit International', 'Ecorys', 'Rexel Nederland', + 'A. Hakpark', 'DuPont Nederland', 'CBRE Group', 'Bolsius', 'Marel', 'Metro', + 'Flynth Adviseurs en Accountants', 'Kropman Installatietechniek', 'Kuijpers', 'Medtronic', 'Cefetra', + 'Simon Loos', 'Citadel Enterprises', 'Intergamma', 'Ceva Logistics', 'Beter Bed', 'Subway', 'Gamma', 'Karwei' + 'Varo Energy', 'APM Terminals', 'Center Parcs', 'Brenntag Nederland', 'NFI', 'Hoogvliet', + 'Van Gansewinkel', 'Nedap', 'Blokker', 'Perfetti Van Melle', 'Vestia', 'Kuehne + Nagel Logistics', + 'Rensa Group', 'NTS Group', 'Joh. Mourik & Co. Holding', 'Mercedes-Benz', 'DIT Personeel', 'Verkade', + 'Hametha', 'Vopak', 'IFF', 'Pearle', 'Mainfreight', 'De Jong & Laan', 'DSV', 'P4People', 'Mazars', 'Cargill', + 'Ten Brinke Groep', 'Alewijnse', 'Agio Cigars', 'Peter Appel Transport', 'Syngenta', 'Avery Dennison', + 'Accon AVM', 'Vitol', 'Vermaat Groep', 'BMC', 'Alcatel-Lucent', 'Maxeda DIY', 'Equens', + 'Van Gelder Groep', 'Emerson Electric Nederland', 'Bakkersland', 'Specsavers', 'E.On', 'Landal Greenparks', + 'IMC Trading', 'Barentz Group', 'Epson', 'Raet', 'Van Oord', 'Thomas Cook Nederland', 'SDU uitgevers', + 'Nedschroef', 'Linde Gas', 'Ewals Cargo Care', 'Theodoor Gilissen', 'TMF Group', 'Cornelis Vrolijk', + 'Jan Linders Supermarkten', 'SIF group', 'BT Nederland', 'Kinepolis', 'Pink Elephant', + 'General Motors Nederland', 'Carlson Wagonlit', 'Bruna', 'Docdata', 'Schenk Tanktransport', 'WPG', 'Peak-IT', + 'Martinair', 'Reesink', 'Elopak Nederland', 'Fagron N.V.', 'OVG Groep', 'Ford Nederland', 'Multi Corporation', + 'Simac', 'Primark', 'Tech Data Nederland', 'Vleesgroothandel Zandbergen', 'Raben Group', 'Farm Frites', + 'Libéma', 'Caldic', 'Portaal', 'Syntus', 'Jacobs DE', 'Stena Line', 'The Phone House', 'Interfood Group', + 'Thales', 'Teva Pharmaceuticals', 'RFS Holland', 'Aebi Schmidt Nederland', + 'Rockwell Automation Nederland', 'Engie Services', 'Hendrix Genetics', 'Qbuzz', 'Unica', + '2SistersFoodGroup', 'Ziut', 'Munckhof Groep', 'Spar Holding', 'Samskip', 'Continental Bakeries', 'Sligro', + 'Merck', 'Foot Locker Europe', 'Unit4', 'PepsiCo', 'Sulzer', 'Tebodin', 'Value8', 'Boels', + 'DKG Groep', 'Bruynzeel Keukens', 'Janssen de Jong Groep', 'ProRail', 'Solid Professionals', 'Hermes Partners', + ) + + def large_company(self): + """ + :example: 'Bol.com' + """ + return self.random_element(self.large_companies) + + def company_prefix(self): + """ + :example 'Stichting' + """ + return self.random_element(self.company_prefixes)	diff --git a/tests/providers/test_company.py b/tests/providers/test_company.py index 0334a08719..ed2ea4a74f 100644 --- a/tests/providers/test_company.py +++ b/tests/providers/test_company.py @@ -13,6 +13,7 @@ from faker.providers.company.pl_PL import ( company_vat_checksum, regon_checksum, local_regon_checksum, Provider as PlProvider, ) +from faker.providers.company.nl_NL import Provider as NlProvider class TestFiFI(unittest.TestCase): @@ -140,3 +141,28 @@ def test_company_suffix(self): suffix = self.factory.company_suffix() assert isinstance(suffix, six.string_types) assert suffix in suffixes + + +class TestNlNL(unittest.TestCase): + """ Tests company in the nl_NL locale """ + + def setUp(self): + self.factory = Faker('nl_NL') + + def test_company_prefix(self): + prefixes = NlProvider.company_prefixes + prefix = self.factory.company_prefix() + assert isinstance(prefix, six.string_types) + assert prefix in prefixes + + def test_company_suffix(self): + suffixes = NlProvider.company_suffixes + suffix = self.factory.company_suffix() + assert isinstance(suffix, six.string_types) + assert suffix in suffixes + + def test_large_companies(self): + companies = NlProvider.large_companies + company = self.factory.large_company() + assert isinstance(company, six.string_types) + assert company in companies		[ { "components": [ { "doc": "", "lines": [ 7, 109 ], "name": "Provider", "signature": "class Provider(CompanyProvider):", "type": "class" }, { "doc": ":example: 'Bol.com'", "lines": [ 99, 103...	[ "tests/providers/test_company.py::TestFiFI::test_company_business_id", "tests/providers/test_company.py::TestJaJP::test_company", "tests/providers/test_company.py::TestPtBR::test_pt_BR_cnpj", "tests/providers/test_company.py::TestPtBR::test_pt_BR_company_id", "tests/providers/test_company.py::TestPtBR::test...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added Dutch company names Added some prefixes and suffixes for common Dutch company names. Also added the top 500 companies in the Netherlands based on: https://www.mt.nl/management/reputatie/mt-500-2018-de-lijst/559930 Closes #929 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/company/nl_NL/__init__.py] (definition of Provider:) class Provider(CompanyProvider): (definition of Provider.large_company:) def large_company(self): """:example: 'Bol.com'""" (definition of Provider.company_prefix:) def company_prefix(self): """:example 'Stichting'""" [end of new definitions in faker/providers/company/nl_NL/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Support for companies for the nl_NL locale I'm currently using faker in a project and would love to use Dutch company namers. I already made changes to do this and would like to commit these. Can you make a branch avaiable for me so I can ask for a merge request? ---------- -------------------- </issues>	6edfdbf6ae90b0153309e3bf066aa3b2d16494a7
sympy__sympy-16276	16,276	sympy/sympy	1.4	6979792bd194c385a851a8e44925b522630d04de	2019-03-16T12:26:02Z	diff --git a/doc/src/modules/plotting.rst b/doc/src/modules/plotting.rst index e9971d11f777..03ace2caa231 100644 --- a/doc/src/modules/plotting.rst +++ b/doc/src/modules/plotting.rst @@ -45,6 +45,12 @@ Plotting Function Reference .. autofunction:: sympy.plotting.plot_implicit.plot_implicit +PlotGrid Class +-------------- + +.. autoclass:: sympy.plotting.plot.PlotGrid + :members: + Series Classes -------------- diff --git a/sympy/plotting/__init__.py b/sympy/plotting/__init__.py index e15b35e40cb5..6ddc146c0d95 100644 --- a/sympy/plotting/__init__.py +++ b/sympy/plotting/__init__.py @@ -2,5 +2,6 @@ from .plot_implicit import plot_implicit from .textplot import textplot from .pygletplot import PygletPlot +from .plot import PlotGrid from .plot import (plot, plot_parametric, plot3d, plot3d_parametric_surface, plot3d_parametric_line) diff --git a/sympy/plotting/plot.py b/sympy/plotting/plot.py index 0ebb68b40b74..6d8d6ca4d53b 100644 --- a/sympy/plotting/plot.py +++ b/sympy/plotting/plot.py @@ -289,6 +289,141 @@ def extend(self, arg): raise TypeError('Expecting Plot or sequence of BaseSeries') +class PlotGrid(object): + """This class helps to plot subplots from already created sympy plots + in a single figure. + + Examples + ======== + + .. plot:: + :context: close-figs + :format: doctest + :include-source: True + + >>> from sympy import symbols + >>> from sympy.plotting import plot, plot3d, PlotGrid + >>> x, y = symbols('x, y') + >>> p1 = plot(x, x2, x3, (x, -5, 5)) + >>> p2 = plot((x2, (x, -6, 6)), (x, (x, -5, 5))) + >>> p3 = plot(x3, (x, -5, 5)) + >>> p4 = plot3d(xy, (x, -5, 5), (y, -5, 5)) + + Plotting vertically in a single line: + + .. plot:: + :context: close-figs + :format: doctest + :include-source: True + + >>> PlotGrid(2, 1 , p1, p2) + PlotGrid object containing: + Plot[0]:Plot object containing: + [0]: cartesian line: x for x over (-5.0, 5.0) + [1]: cartesian line: x2 for x over (-5.0, 5.0) + [2]: cartesian line: x3 for x over (-5.0, 5.0) + Plot[1]:Plot object containing: + [0]: cartesian line: x2 for x over (-6.0, 6.0) + [1]: cartesian line: x for x over (-5.0, 5.0) + + Plotting horizontally in a single line: + + .. plot:: + :context: close-figs + :format: doctest + :include-source: True + + >>> PlotGrid(1, 3 , p2, p3, p4) + PlotGrid object containing: + Plot[0]:Plot object containing: + [0]: cartesian line: x2 for x over (-6.0, 6.0) + [1]: cartesian line: x for x over (-5.0, 5.0) + Plot[1]:Plot object containing: + [0]: cartesian line: x3 for x over (-5.0, 5.0) + Plot[2]:Plot object containing: + [0]: cartesian surface: xy for x over (-5.0, 5.0) and y over (-5.0, 5.0) + + Plotting in a grid form: + + .. plot:: + :context: close-figs + :format: doctest + :include-source: True + + >>> PlotGrid(2, 2, p1, p2 ,p3, p4) + PlotGrid object containing: + Plot[0]:Plot object containing: + [0]: cartesian line: x for x over (-5.0, 5.0) + [1]: cartesian line: x2 for x over (-5.0, 5.0) + [2]: cartesian line: x3 for x over (-5.0, 5.0) + Plot[1]:Plot object containing: + [0]: cartesian line: x2 for x over (-6.0, 6.0) + [1]: cartesian line: x for x over (-5.0, 5.0) + Plot[2]:Plot object containing: + [0]: cartesian line: x3 for x over (-5.0, 5.0) + Plot[3]:Plot object containing: + [0]: cartesian surface: xy for x over (-5.0, 5.0) and y over (-5.0, 5.0) + + """ + def __init__(self, nrows, ncolumns, args, *kwargs): + """ + Parameters + ========== + + nrows : The number of rows that should be in the grid of the + required subplot + ncolumns : The number of columns that should be in the grid + of the required subplot + + nrows and ncolumns together define the required grid + + Arguments + ========= + + A list of predefined plot objects entered in a row-wise sequence + i.e. plot objects which are to be in the top row of the required + grid are written first, then the second row objects and so on + + Keyword arguments + ================= + + show : Boolean + The default value is set to ``True``. Set show to ``False`` and + the function will not display the subplot. The returned instance + of the ``PlotGrid`` class can then be used to save or display the + plot by calling the ``save()`` and ``show()`` methods + respectively. + """ + self.nrows = nrows + self.ncolumns = ncolumns + self._series = [] + self.args = args + for arg in args: + self._series.append(arg._series) + self.backend = DefaultBackend + show = kwargs.pop('show', True) + if show: + self.show() + + def show(self): + if hasattr(self, '_backend'): + self._backend.close() + self._backend = self.backend(self) + self._backend.show() + + def save(self, path): + if hasattr(self, '_backend'): + self._backend.close() + self._backend = self.backend(self) + self._backend.save(path) + + def __str__(self): + plot_strs = [('Plot[%d]:' % i) + str(plot) + for i, plot in enumerate(self.args)] + + return 'PlotGrid object containing:\n' + '\n'.join(plot_strs) + + ############################################################################## # Data Series ############################################################################## @@ -908,80 +1043,90 @@ def __init__(self, parent): class MatplotlibBackend(BaseBackend): def __init__(self, parent): super(MatplotlibBackend, self).__init__(parent) - are_3D = [s.is_3D for s in self.parent._series] self.matplotlib = import_module('matplotlib', __import__kwargs={'fromlist': ['pyplot', 'cm', 'collections']}, min_module_version='1.1.0', catch=(RuntimeError,)) self.plt = self.matplotlib.pyplot self.cm = self.matplotlib.cm self.LineCollection = self.matplotlib.collections.LineCollection - if any(are_3D) and not all(are_3D): - raise ValueError('The matplotlib backend can not mix 2D and 3D.') - elif not any(are_3D): - self.fig = self.plt.figure() - self.ax = self.fig.add_subplot(111) - self.ax.spines['left'].set_position('zero') - self.ax.spines['right'].set_color('none') - self.ax.spines['bottom'].set_position('zero') - self.ax.spines['top'].set_color('none') - self.ax.spines['left'].set_smart_bounds(True) - self.ax.spines['bottom'].set_smart_bounds(False) - self.ax.xaxis.set_ticks_position('bottom') - self.ax.yaxis.set_ticks_position('left') - elif all(are_3D): - ## mpl_toolkits.mplot3d is necessary for - ## projection='3d' - mpl_toolkits = import_module('mpl_toolkits', - __import__kwargs={'fromlist': ['mplot3d']}) - self.fig = self.plt.figure() - self.ax = self.fig.add_subplot(111, projection='3d') - def process_series(self): - parent = self.parent + if isinstance(self.parent, Plot): + nrows, ncolumns = 1, 1 + series_list = [self.parent._series] + elif isinstance(self.parent, PlotGrid): + nrows, ncolumns = self.parent.nrows, self.parent.ncolumns + series_list = self.parent._series + + self.ax = [] + self.fig = self.plt.figure() - for s in self.parent._series: + for i, series in enumerate(series_list): + are_3D = [s.is_3D for s in series] + + if any(are_3D) and not all(are_3D): + raise ValueError('The matplotlib backend can not mix 2D and 3D.') + elif all(are_3D): + # mpl_toolkits.mplot3d is necessary for + # projection='3d' + mpl_toolkits = import_module('mpl_toolkits', + __import__kwargs={'fromlist': ['mplot3d']}) + self.ax.append(self.fig.add_subplot(nrows, ncolumns, i + 1, projection='3d')) + + elif not any(are_3D): + self.ax.append(self.fig.add_subplot(nrows, ncolumns, i + 1)) + self.ax[i].spines['left'].set_position('zero') + self.ax[i].spines['right'].set_color('none') + self.ax[i].spines['bottom'].set_position('zero') + self.ax[i].spines['top'].set_color('none') + self.ax[i].spines['left'].set_smart_bounds(True) + self.ax[i].spines['bottom'].set_smart_bounds(False) + self.ax[i].xaxis.set_ticks_position('bottom') + self.ax[i].yaxis.set_ticks_position('left') + + def _process_series(self, series, ax, parent): + for s in series: # Create the collections if s.is_2Dline: collection = self.LineCollection(s.get_segments()) - self.ax.add_collection(collection) + ax.add_collection(collection) elif s.is_contour: - self.ax.contour(s.get_meshes()) + ax.contour(s.get_meshes()) elif s.is_3Dline: # TODO too complicated, I blame matplotlib mpl_toolkits = import_module('mpl_toolkits', __import__kwargs={'fromlist': ['mplot3d']}) art3d = mpl_toolkits.mplot3d.art3d collection = art3d.Line3DCollection(s.get_segments()) - self.ax.add_collection(collection) + ax.add_collection(collection) x, y, z = s.get_points() - self.ax.set_xlim((min(x), max(x))) - self.ax.set_ylim((min(y), max(y))) - self.ax.set_zlim((min(z), max(z))) + ax.set_xlim((min(x), max(x))) + ax.set_ylim((min(y), max(y))) + ax.set_zlim((min(z), max(z))) elif s.is_3Dsurface: x, y, z = s.get_meshes() - collection = self.ax.plot_surface(x, y, z, + collection = ax.plot_surface(x, y, z, cmap=getattr(self.cm, 'viridis', self.cm.jet), rstride=1, cstride=1, linewidth=0.1) elif s.is_implicit: - #Smart bounds have to be set to False for implicit plots. - self.ax.spines['left'].set_smart_bounds(False) - self.ax.spines['bottom'].set_smart_bounds(False) + # Smart bounds have to be set to False for implicit plots. + ax.spines['left'].set_smart_bounds(False) + ax.spines['bottom'].set_smart_bounds(False) points = s.get_raster() if len(points) == 2: - #interval math plotting + # interval math plotting x, y = _matplotlib_list(points[0]) - self.ax.fill(x, y, facecolor=s.line_color, edgecolor='None') + ax.fill(x, y, facecolor=s.line_color, edgecolor='None') else: # use contourf or contour depending on whether it is # an inequality or equality. - #XXX: ``contour`` plots multiple lines. Should be fixed. + # XXX: ``contour`` plots multiple lines. Should be fixed. ListedColormap = self.matplotlib.colors.ListedColormap colormap = ListedColormap(["white", s.line_color]) xarray, yarray, zarray, plot_type = points if plot_type == 'contour': - self.ax.contour(xarray, yarray, zarray, cmap=colormap) + ax.contour(xarray, yarray, zarray, cmap=colormap) else: - self.ax.contourf(xarray, yarray, zarray, cmap=colormap) + ax.contourf(xarray, yarray, zarray, cmap=colormap) else: raise ValueError('The matplotlib backend supports only ' 'is_2Dline, is_3Dline, is_3Dsurface and ' @@ -1010,14 +1155,13 @@ def process_series(self): # Set global options. # TODO The 3D stuff # XXX The order of those is important. - mpl_toolkits = import_module('mpl_toolkits', __import__kwargs={'fromlist': ['mplot3d']}) Axes3D = mpl_toolkits.mplot3d.Axes3D - if parent.xscale and not isinstance(self.ax, Axes3D): - self.ax.set_xscale(parent.xscale) - if parent.yscale and not isinstance(self.ax, Axes3D): - self.ax.set_yscale(parent.yscale) + if parent.xscale and not isinstance(ax, Axes3D): + ax.set_xscale(parent.xscale) + if parent.yscale and not isinstance(ax, Axes3D): + ax.set_yscale(parent.yscale) if parent.xlim: from sympy.core.basic import Basic xlim = parent.xlim @@ -1028,12 +1172,12 @@ def process_series(self): raise ValueError( "All numbers from xlim={} must be finite".format(xlim)) xlim = (float(i) for i in xlim) - self.ax.set_xlim(xlim) + ax.set_xlim(xlim) else: if all(isinstance(s, LineOver1DRangeSeries) for s in parent._series): starts = [s.start for s in parent._series] ends = [s.end for s in parent._series] - self.ax.set_xlim(min(starts), max(ends)) + ax.set_xlim(min(starts), max(ends)) if parent.ylim: from sympy.core.basic import Basic ylim = parent.ylim @@ -1044,40 +1188,56 @@ def process_series(self): raise ValueError( "All numbers from ylim={} must be finite".format(ylim)) ylim = (float(i) for i in ylim) - self.ax.set_ylim(ylim) - if not isinstance(self.ax, Axes3D) or self.matplotlib.__version__ >= '1.2.0': # XXX in the distant future remove this check - self.ax.set_autoscale_on(parent.autoscale) + ax.set_ylim(ylim) + if not isinstance(ax, Axes3D) or self.matplotlib.__version__ >= '1.2.0': # XXX in the distant future remove this check + ax.set_autoscale_on(parent.autoscale) if parent.axis_center: val = parent.axis_center - if isinstance(self.ax, Axes3D): + if isinstance(ax, Axes3D): pass elif val == 'center': - self.ax.spines['left'].set_position('center') - self.ax.spines['bottom'].set_position('center') + ax.spines['left'].set_position('center') + ax.spines['bottom'].set_position('center') elif val == 'auto': - xl, xh = self.ax.get_xlim() - yl, yh = self.ax.get_ylim() + xl, xh = ax.get_xlim() + yl, yh = ax.get_ylim() pos_left = ('data', 0) if xlxh <= 0 else 'center' pos_bottom = ('data', 0) if yl*yh <= 0 else 'center' - self.ax.spines['left'].set_position(pos_left) - self.ax.spines['bottom'].set_position(pos_bottom) + ax.spines['left'].set_position(pos_left) + ax.spines['bottom'].set_position(pos_bottom) else: - self.ax.spines['left'].set_position(('data', val[0])) - self.ax.spines['bottom'].set_position(('data', val[1])) + ax.spines['left'].set_position(('data', val[0])) + ax.spines['bottom'].set_position(('data', val[1])) if not parent.axis: - self.ax.set_axis_off() + ax.set_axis_off() if parent.legend: - if self.ax.legend(): - self.ax.legend_.set_visible(parent.legend) + if ax.legend(): + ax.legend_.set_visible(parent.legend) if parent.margin: - self.ax.set_xmargin(parent.margin) - self.ax.set_ymargin(parent.margin) + ax.set_xmargin(parent.margin) + ax.set_ymargin(parent.margin) if parent.title: - self.ax.set_title(parent.title) + ax.set_title(parent.title) if parent.xlabel: - self.ax.set_xlabel(parent.xlabel, position=(1, 0)) + ax.set_xlabel(parent.xlabel, position=(1, 0)) if parent.ylabel: - self.ax.set_ylabel(parent.ylabel, position=(0, 1)) + ax.set_ylabel(parent.ylabel, position=(0, 1)) + + def process_series(self): + """ + Iterates over every ``Plot`` object and further calls + _process_series() + """ + parent = self.parent + if isinstance(parent, Plot): + series_list = [parent._series] + else: + series_list = parent._series + + for i, (series, ax) in enumerate(zip(series_list, self.ax)): + if isinstance(self.parent, PlotGrid): + parent = self.parent.args[i] + self._process_series(series, ax, parent) def show(self): self.process_series() @@ -1085,6 +1245,7 @@ def show(self): # you can uncomment the next line and remove the pyplot.show() call #self.fig.show() if _show: + self.fig.tight_layout() self.plt.show() else: self.close()	diff --git a/sympy/plotting/tests/test_plot.py b/sympy/plotting/tests/test_plot.py index 3052951889b0..a4a1488c11d1 100644 --- a/sympy/plotting/tests/test_plot.py +++ b/sympy/plotting/tests/test_plot.py @@ -2,7 +2,7 @@ oo, LambertW, I, meijerg, exp_polar, Max, Piecewise, And) from sympy.plotting import (plot, plot_parametric, plot3d_parametric_line, plot3d, plot3d_parametric_surface) -from sympy.plotting.plot import unset_show, plot_contour +from sympy.plotting.plot import unset_show, plot_contour, PlotGrid from sympy.utilities import lambdify as lambdify_ from sympy.utilities.pytest import skip, raises, warns from sympy.plotting.experimental_lambdify import lambdify @@ -323,6 +323,37 @@ def plot_and_save_6(name): + meijerg(((1/2,), ()), ((5, 0, 1/2), ()), 5x2 exp_polar(Ipi)/2)) / (48 pi), (x, 1e-6, 1e-2)).save(tmp_file()) + +def plotgrid_and_save(name): + tmp_file = TmpFileManager.tmp_file + + x = Symbol('x') + y = Symbol('y') + z = Symbol('z') + p1 = plot(x) + p2 = plot_parametric((sin(x), cos(x)), (x, sin(x)), show=False) + p3 = plot_parametric(cos(x), sin(x), adaptive=False, nb_of_points=500, show=False) + p4 = plot3d_parametric_line(sin(x), cos(x), x, show=False) + # symmetric grid + p = PlotGrid(2, 2, p1, p2, p3, p4) + p.save(tmp_file('%s_grid1' % name)) + p._backend.close() + + # grid size greater than the number of subplots + p = PlotGrid(3, 4, p1, p2, p3, p4) + p.save(tmp_file('%s_grid2' % name)) + p._backend.close() + + p5 = plot(cos(x),(x, -pi, pi), show=False) + p5[0].line_color = lambda a: a + p6 = plot(Piecewise((1, x > 0), (0, True)), (x, -1, 1), show=False) + p7 = plot_contour((x2 + y2, (x, -5, 5), (y, -5, 5)), (x3 + y3, (x, -3, 3), (y, -3, 3)), show=False) + # unsymmetric grid (subplots in one line) + p = PlotGrid(1, 3, p5, p6, p7) + p.save(tmp_file('%s_grid3' % name)) + p._backend.close() + + def test_matplotlib_1(): matplotlib = import_module('matplotlib', min_module_version='1.1.0', catch=(RuntimeError,)) @@ -395,6 +426,20 @@ def test_matplotlib_6(): else: skip("Matplotlib not the default backend") + +def test_matplotlib_7(): + + matplotlib = import_module('matplotlib', min_module_version='1.1.0', catch=(RuntimeError,)) + if matplotlib: + try: + plotgrid_and_save('test') + finally: + # clean up + TmpFileManager.cleanup() + else: + skip("Matplotlib not the default backend") + + # Tests for exception handling in experimental_lambdify def test_experimental_lambify(): x = Symbol('x')	diff --git a/doc/src/modules/plotting.rst b/doc/src/modules/plotting.rst index e9971d11f777..03ace2caa231 100644 --- a/doc/src/modules/plotting.rst +++ b/doc/src/modules/plotting.rst @@ -45,6 +45,12 @@ Plotting Function Reference .. autofunction:: sympy.plotting.plot_implicit.plot_implicit +PlotGrid Class +-------------- + +.. autoclass:: sympy.plotting.plot.PlotGrid + :members: + Series Classes --------------	[ { "components": [ { "doc": "This class helps to plot subplots from already created sympy plots\nin a single figure.\n\nExamples\n========\n\n.. plot::\n :context: close-figs\n :format: doctest\n :include-source: True\n\n >>> from sympy import symbols\n >>> from sympy.plotting import pl...	[ "test_experimental_lambify" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> added functionality to obtain subplots from already created plots. This PR gives a solution to the problem as discussed in Issue #15328 A class `PlotGrid` have been introduced in `plot.py` of plotting module. This class takes some already created `Plot` objects and makes a subplot figure using`matplotlib` backend. TODO's: - [x] Improve documentation - [x] Add tests #### Release Notes <!-- BEGIN RELEASE NOTES --> - plotting - plotting module can now create subplots i.e can plot more than one plot in a single figure using `PlotGrid` <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/plotting/plot.py] (definition of PlotGrid:) class PlotGrid(object): """This class helps to plot subplots from already created sympy plots in a single figure. Examples ======== .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy import symbols >>> from sympy.plotting import plot, plot3d, PlotGrid >>> x, y = symbols('x, y') >>> p1 = plot(x, x2, x3, (x, -5, 5)) >>> p2 = plot((x2, (x, -6, 6)), (x, (x, -5, 5))) >>> p3 = plot(x3, (x, -5, 5)) >>> p4 = plot3d(xy, (x, -5, 5), (y, -5, 5)) Plotting vertically in a single line: .. plot:: :context: close-figs :format: doctest :include-source: True >>> PlotGrid(2, 1 , p1, p2) PlotGrid object containing: Plot[0]:Plot object containing: [0]: cartesian line: x for x over (-5.0, 5.0) [1]: cartesian line: x2 for x over (-5.0, 5.0) [2]: cartesian line: x3 for x over (-5.0, 5.0) Plot[1]:Plot object containing: [0]: cartesian line: x2 for x over (-6.0, 6.0) [1]: cartesian line: x for x over (-5.0, 5.0) Plotting horizontally in a single line: .. plot:: :context: close-figs :format: doctest :include-source: True >>> PlotGrid(1, 3 , p2, p3, p4) PlotGrid object containing: Plot[0]:Plot object containing: [0]: cartesian line: x2 for x over (-6.0, 6.0) [1]: cartesian line: x for x over (-5.0, 5.0) Plot[1]:Plot object containing: [0]: cartesian line: x3 for x over (-5.0, 5.0) Plot[2]:Plot object containing: [0]: cartesian surface: xy for x over (-5.0, 5.0) and y over (-5.0, 5.0) Plotting in a grid form: .. plot:: :context: close-figs :format: doctest :include-source: True >>> PlotGrid(2, 2, p1, p2 ,p3, p4) PlotGrid object containing: Plot[0]:Plot object containing: [0]: cartesian line: x for x over (-5.0, 5.0) [1]: cartesian line: x2 for x over (-5.0, 5.0) [2]: cartesian line: x3 for x over (-5.0, 5.0) Plot[1]:Plot object containing: [0]: cartesian line: x2 for x over (-6.0, 6.0) [1]: cartesian line: x for x over (-5.0, 5.0) Plot[2]:Plot object containing: [0]: cartesian line: x3 for x over (-5.0, 5.0) Plot[3]:Plot object containing: [0]: cartesian surface: xy for x over (-5.0, 5.0) and y over (-5.0, 5.0)""" (definition of PlotGrid.__init__:) def __init__(self, nrows, ncolumns, args, **kwargs): """Parameters ========== nrows : The number of rows that should be in the grid of the required subplot ncolumns : The number of columns that should be in the grid of the required subplot nrows and ncolumns together define the required grid Arguments ========= A list of predefined plot objects entered in a row-wise sequence i.e. plot objects which are to be in the top row of the required grid are written first, then the second row objects and so on Keyword arguments ================= show : Boolean The default value is set to ``True``. Set show to ``False`` and the function will not display the subplot. The returned instance of the ``PlotGrid`` class can then be used to save or display the plot by calling the ``save()`` and ``show()`` methods respectively.""" (definition of PlotGrid.show:) def show(self): (definition of PlotGrid.save:) def save(self, path): (definition of PlotGrid.__str__:) def __str__(self): (definition of MatplotlibBackend._process_series:) def _process_series(self, series, ax, parent): [end of new definitions in sympy/plotting/plot.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		e941ad69638189ea42507331e417b88837357dec
sympy__sympy-16253	16,253	sympy/sympy	1.4	93a65b9bb8a615906e73d5885ff03076bcabc555	2019-03-14T05:24:14Z	diff --git a/sympy/utilities/misc.py b/sympy/utilities/misc.py index 89b3ec95adf9..af19d67f3bdf 100644 --- a/sympy/utilities/misc.py +++ b/sympy/utilities/misc.py @@ -7,7 +7,8 @@ import re as _re import struct from textwrap import fill, dedent -from sympy.core.compatibility import get_function_name, range, as_int +from sympy.core.compatibility import (get_function_name, range, as_int, + string_types) @@ -24,13 +25,71 @@ def filldedent(s, w=70): Empty line stripping serves to deal with docstrings like this one that start with a newline after the initial triple quote, inserting an empty - line at the beginning of the string.""" + line at the beginning of the string. + + See Also + ======== + strlines, rawlines + """ return '\n' + fill(dedent(str(s)).strip('\n'), width=w) +def strlines(s, c=64, short=False): + """Return a cut-and-pastable string that, when printed, is + equivalent to the input. The lines will be surrounded by + parentheses and no line will be longer than c (default 64) + characters. If the line contains newlines characters, the + `rawlines` result will be returned. If ``short`` is True + (default is False) then if there is one line it will be + returned without bounding parentheses. + + Examples + ======== + + >>> from sympy.utilities.misc import strlines + >>> q = 'this is a long string that should be broken into shorter lines' + >>> print(strlines(q, 40)) + ( + 'this is a long string that should be b' + 'roken into shorter lines' + ) + >>> q == ( + ... 'this is a long string that should be b' + ... 'roken into shorter lines' + ... ) + True + + See Also + ======== + filldedent, rawlines + """ + if type(s) not in string_types: + raise ValueError('expecting string input') + if '\n' in s: + return rawlines(s) + q = '"' if repr(s).startswith('"') else "'" + q = (q,)*2 + if '\\' in s: # use r-string + m = '(\nr%s%%s%s\n)' % q + j = '%s\nr%s' % q + c -= 3 + else: + m = '(\n%s%%s%s\n)' % q + j = '%s\n%s' % q + c -= 2 + out = [] + while s: + out.append(s[:c]) + s=s[c:] + if short and len(out) == 1: + return (m % out[0]).splitlines()[1] # strip bounding (\n...\n) + return m % j.join(out) + + def rawlines(s): """Return a cut-and-pastable string that, when printed, is equivalent - to the input. The string returned is formatted so it can be indented + to the input. Use this when there is more than one line in the + string. The string returned is formatted so it can be indented nicely within tests; in some cases it is wrapped in the dedent function which has to be imported from textwrap. @@ -82,22 +141,26 @@ def rawlines(s): 'that\\n' ' ' ) + + See Also + ======== + filldedent, strlines """ lines = s.split('\n') if len(lines) == 1: return repr(lines[0]) triple = ["'''" in s, '"""' in s] if any(li.endswith(' ') for li in lines) or '\\' in s or all(triple): - rv = ["("] + rv = [] # add on the newlines trailing = s.endswith('\n') last = len(lines) - 1 for i, li in enumerate(lines): if i != last or trailing: - rv.append(repr(li)[:-1] + '\\n\'') + rv.append(repr(li + '\n')) else: rv.append(repr(li)) - return '\n '.join(rv) + '\n)' + return '(\n %s\n)' % '\n '.join(rv) else: rv = '\n '.join(lines) if triple[0]:	diff --git a/sympy/utilities/tests/test_misc.py b/sympy/utilities/tests/test_misc.py index 63d2203820ab..3eae4cdeb0a2 100644 --- a/sympy/utilities/tests/test_misc.py +++ b/sympy/utilities/tests/test_misc.py @@ -1,5 +1,6 @@ +from textwrap import dedent from sympy.core.compatibility import range, unichr -from sympy.utilities.misc import translate, replace, ordinal, rawlines +from sympy.utilities.misc import translate, replace, ordinal, rawlines, strlines def test_translate(): abc = 'abc' @@ -41,3 +42,45 @@ def test_ordinal(): def test_rawlines(): assert rawlines('a a\na') == "dedent('''\\\n a a\n a''')" assert rawlines('a a') == "'a a'" + assert rawlines(strlines('\\le"ft')) == ( + '(\n' + " '(\\n'\n" + ' \'r\\\'\\\\le"ft\\\'\\n\'\n' + " ')'\n" + ')') + + +def test_strlines(): + q = 'this quote (") is in the middle' + # the following assert rhs was prepared with + # print(rawlines(strlines(q, 10))) + assert strlines(q, 10) == dedent('''\ + ( + 'this quo' + 'te (") i' + 's in the' + ' middle' + )''') + assert q == ( + 'this quo' + 'te (") i' + 's in the' + ' middle' + ) + q = "this quote (') is in the middle" + assert strlines(q, 20) == dedent('''\ + ( + "this quote (') is " + "in the middle" + )''') + assert strlines('\\left') == ( + '(\n' + "r'\\left'\n" + ')') + assert strlines('\\left', short=True) == r"r'\left'" + assert strlines('\\le"ft') == ( + '(\n' + 'r\'\\le"ft\'\n' + ')') + q = 'this\nother line' + assert strlines(q) == rawlines(q)		[ { "components": [ { "doc": "Return a cut-and-pastable string that, when printed, is\nequivalent to the input. The lines will be surrounded by\nparentheses and no line will be longer than c (default 64)\ncharacters. If the line contains newlines characters, the\n`rawlines` result will be returned....	[ "test_translate", "test_replace", "test_ordinal", "test_rawlines" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> misc: add strlines When wanting to test the output that is a long string and needing to keep lines under 72 characters, it is a bit tedious to split the line and add the quotes. `strlines` can help in the process. It will use rawlines if necessary, too. ``` Given: func(s) -> longstring print(strlines(func(s))) <copy what was printed> Now you can test func(s) == <paste> ``` Here is an example of it wrapping a string to a width of 30 ```python >>> q = 'this is a long string that just needs to be shorter' >>> print(strlines(q, 30)) ( 'this is a long string that j' 'ust needs to be shorter' ) >>> q == ( ... 'this is a long string that j' ... 'ust needs to be shorter' ... ) True ``` A quoting issue was fixed for rawlines, too. Instead of adding a quote character, the repr form is used. <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed #### Other comments `strlines` will automatically call rawlines if there is more than one logical line in the input #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - utilities - `strlines` added: prints a string into shorter lines in a format that can be copied and used in an equality test <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/utilities/misc.py] (definition of strlines:) def strlines(s, c=64, short=False): """Return a cut-and-pastable string that, when printed, is equivalent to the input. The lines will be surrounded by parentheses and no line will be longer than c (default 64) characters. If the line contains newlines characters, the `rawlines` result will be returned. If ``short`` is True (default is False) then if there is one line it will be returned without bounding parentheses. Examples ======== >>> from sympy.utilities.misc import strlines >>> q = 'this is a long string that should be broken into shorter lines' >>> print(strlines(q, 40)) ( 'this is a long string that should be b' 'roken into shorter lines' ) >>> q == ( ... 'this is a long string that should be b' ... 'roken into shorter lines' ... ) True See Also ======== filldedent, rawlines""" [end of new definitions in sympy/utilities/misc.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		e941ad69638189ea42507331e417b88837357dec
sympy__sympy-16248	16,248	sympy/sympy	1.4	35b7b87c03f8cbbd7d185e55af8170702eb861af	2019-03-13T16:47:06Z	diff --git a/sympy/combinatorics/perm_groups.py b/sympy/combinatorics/perm_groups.py index b9aebfb6f47b..38f2a3130ecd 100644 --- a/sympy/combinatorics/perm_groups.py +++ b/sympy/combinatorics/perm_groups.py @@ -1678,6 +1678,31 @@ def is_abelian(self): return False return True + def is_elementary(self, p): + """Return ``True`` if the group is elementary abelian. An elementary + abelian group is a finite abelian group, where every nontrivial + element has order `p`, where `p` is a prime. + + Examples + ======== + + >>> from sympy.combinatorics import Permutation + >>> from sympy.combinatorics.perm_groups import PermutationGroup + >>> a = Permutation([0, 2, 1]) + >>> G = PermutationGroup([a]) + >>> G.is_elementary(2) + True + >>> a = Permutation([0, 2, 1, 3]) + >>> b = Permutation([3, 1, 2, 0]) + >>> G = PermutationGroup([a, b]) + >>> G.is_elementary(2) + True + >>> G.is_elementary(3) + False + + """ + return self.is_abelian and all(g.order() == p for g in self.generators) + def is_alt_sym(self, eps=0.05, _random_prec=None): r"""Monte Carlo test for the symmetric/alternating group for degrees >= 8. @@ -2073,6 +2098,25 @@ def is_subgroup(self, G, strict=True): return False return all(G.contains(g, strict=strict) for g in gens) + @property + def is_polycyclic(self): + """Return ``True`` if a group is polycyclic. A group is polycyclic if + it has a subnormal series with cyclic factors. For finite groups, + this is the same as if the group is solvable. + + Examples + ======== + + >>> from sympy.combinatorics import Permutation, PermutationGroup + >>> a = Permutation([0, 2, 1, 3]) + >>> b = Permutation([2, 0, 1, 3]) + >>> G = PermutationGroup([a, b]) + >>> G.is_polycyclic + True + + """ + return self.is_solvable + def is_transitive(self, strict=True): """Test if the group is transitive.	diff --git a/sympy/combinatorics/tests/test_perm_groups.py b/sympy/combinatorics/tests/test_perm_groups.py index 64dd4d299d11..0c03f4a5741c 100644 --- a/sympy/combinatorics/tests/test_perm_groups.py +++ b/sympy/combinatorics/tests/test_perm_groups.py @@ -888,3 +888,34 @@ def _strong_test(P): c = Permutation(4,5) P = PermutationGroup(c, a, b) assert _strong_test(P) + + +def test_polycyclic(): + a = Permutation([0, 1, 2]) + b = Permutation([2, 1, 0]) + G = PermutationGroup([a, b]) + assert G.is_polycyclic == True + + a = Permutation([1, 2, 3, 4, 0]) + b = Permutation([1, 0, 2, 3, 4]) + G = PermutationGroup([a, b]) + assert G.is_polycyclic == False + + +def test_elementary(): + a = Permutation([1, 5, 2, 0, 3, 6, 4]) + G = PermutationGroup([a]) + assert G.is_elementary(7) == False + + a = Permutation(0, 1)(2, 3) + b = Permutation(0, 2)(3, 1) + G = PermutationGroup([a, b]) + assert G.is_elementary(2) == True + c = Permutation(4, 5, 6) + G = PermutationGroup([a, b, c]) + assert G.is_elementary(2) == False + + G = SymmetricGroup(4).sylow_subgroup(2) + assert G.is_elementary(2) == False + H = AlternatingGroup(4).sylow_subgroup(2) + assert H.is_elementary(2) == True		[ { "components": [ { "doc": "Return ``True`` if the group is elementary abelian. An elementary\nabelian group is a finite abelian group, where every nontrivial\nelement has order `p`, where `p` is a prime.\n\nExamples\n========\n\n>>> from sympy.combinatorics import Permutation\n>>> from sympy.comb...	[ "test_polycyclic" ]	[ "test_has", "test_generate", "test_order", "test_equality", "test_stabilizer", "test_center", "test_centralizer", "test_coset_rank", "test_coset_factor", "test_orbits", "test_is_normal", "test_eq", "test_derived_subgroup", "test_is_solvable", "test_rubik1", "test_direct_product", "te...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add Elementary and Polycyclic groups in Permutation groups <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed `Elementary` and `Polycyclic` groups has been implemented where `Elementary Group` is defined as a finite `abelian group`, where every `nontrivial` element has an order of `p`, where `p` is a `prime` and `Polycyclic Group` for a finite group is same as `solvable group`. One TODO task may be implementing polycyclic_group for infiite groups. #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * combinatorics * elementary and polycyclic groups has been added to perm_groups.py <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/combinatorics/perm_groups.py] (definition of PermutationGroup.is_elementary:) def is_elementary(self, p): """Return ``True`` if the group is elementary abelian. An elementary abelian group is a finite abelian group, where every nontrivial element has order `p`, where `p` is a prime. Examples ======== >>> from sympy.combinatorics import Permutation >>> from sympy.combinatorics.perm_groups import PermutationGroup >>> a = Permutation([0, 2, 1]) >>> G = PermutationGroup([a]) >>> G.is_elementary(2) True >>> a = Permutation([0, 2, 1, 3]) >>> b = Permutation([3, 1, 2, 0]) >>> G = PermutationGroup([a, b]) >>> G.is_elementary(2) True >>> G.is_elementary(3) False""" (definition of PermutationGroup.is_polycyclic:) def is_polycyclic(self): """Return ``True`` if a group is polycyclic. A group is polycyclic if it has a subnormal series with cyclic factors. For finite groups, this is the same as if the group is solvable. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([0, 2, 1, 3]) >>> b = Permutation([2, 0, 1, 3]) >>> G = PermutationGroup([a, b]) >>> G.is_polycyclic True""" [end of new definitions in sympy/combinatorics/perm_groups.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		e941ad69638189ea42507331e417b88837357dec
scikit-learn__scikit-learn-13439	13,439	scikit-learn/scikit-learn	0.21	a62775e99f2a5ea3d51db7160fad783f6cd8a4c5	2019-03-12T20:32:50Z	diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 8787b07d5347e..cd4daebf9632b 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -413,6 +413,10 @@ Support for Python 3.4 and below has been officially dropped. - \|API\| :class:`pipeline.Pipeline` now supports using ``'passthrough'`` as a transformer. :issue:`11144` by :user:`Thomas Fan <thomasjpfan>`. +- \|Enhancement\| :class:`pipeline.Pipeline` implements ``__len__`` and + therefore ``len(pipeline)`` returns the number of steps in the pipeline. + :issue:`13439` by :user:`Lakshya KD <LakshKD>`. + :mod:`sklearn.preprocessing` ............................ diff --git a/sklearn/pipeline.py b/sklearn/pipeline.py index 7eaf9a46f09e9..d1d03656d2a62 100644 --- a/sklearn/pipeline.py +++ b/sklearn/pipeline.py @@ -199,6 +199,12 @@ def _iter(self, with_final=True): if trans is not None and trans != 'passthrough': yield idx, name, trans + def __len__(self): + """ + Returns the length of the Pipeline + """ + return len(self.steps) + def __getitem__(self, ind): """Returns a sub-pipeline or a single esimtator in the pipeline	diff --git a/sklearn/tests/test_pipeline.py b/sklearn/tests/test_pipeline.py index 8d6fe8f70374e..ed81db747e20c 100644 --- a/sklearn/tests/test_pipeline.py +++ b/sklearn/tests/test_pipeline.py @@ -1069,5 +1069,6 @@ def test_make_pipeline_memory(): assert pipeline.memory is memory pipeline = make_pipeline(DummyTransf(), SVC()) assert pipeline.memory is None + assert len(pipeline) == 2 shutil.rmtree(cachedir)	diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 8787b07d5347e..cd4daebf9632b 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -413,6 +413,10 @@ Support for Python 3.4 and below has been officially dropped. - \|API\| :class:`pipeline.Pipeline` now supports using ``'passthrough'`` as a transformer. :issue:`11144` by :user:`Thomas Fan <thomasjpfan>`. +- \|Enhancement\| :class:`pipeline.Pipeline` implements ``__len__`` and + therefore ``len(pipeline)`` returns the number of steps in the pipeline. + :issue:`13439` by :user:`Lakshya KD <LakshKD>`. + :mod:`sklearn.preprocessing` ............................	[ { "components": [ { "doc": "Returns the length of the Pipeline", "lines": [ 202, 206 ], "name": "Pipeline.__len__", "signature": "def __len__(self):", "type": "function" } ], "file": "sklearn/pipeline.py" } ]	[ "sklearn/tests/test_pipeline.py::test_make_pipeline_memory" ]	[ "sklearn/tests/test_pipeline.py::test_pipeline_init", "sklearn/tests/test_pipeline.py::test_pipeline_init_tuple", "sklearn/tests/test_pipeline.py::test_pipeline_methods_anova", "sklearn/tests/test_pipeline.py::test_pipeline_fit_params", "sklearn/tests/test_pipeline.py::test_pipeline_sample_weight_supported"...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> adding length function to pipeline.py <!-- Thanks for contributing a pull request! Please ensure you have taken a look at the contribution guidelines: https://github.com/scikit-learn/scikit-learn/blob/master/CONTRIBUTING.md#pull-request-checklist --> #### Reference Issues/PRs <!-- Example: Fixes #1234. See also #3456. Please use keywords (e.g., Fixes) to create link to the issues or pull requests you resolved, so that they will automatically be closed when your pull request is merged. See https://github.com/blog/1506-closing-issues-via-pull-requests --> Fixes #13418 #### What does this implement/fix? Explain your changes. Adding length function in pipeline.py file that will return the length of the pipeline. #### Any other comments? <!-- Please be aware that we are a loose team of volunteers so patience is necessary; assistance handling other issues is very welcome. We value all user contributions, no matter how minor they are. If we are slow to review, either the pull request needs some benchmarking, tinkering, convincing, etc. or more likely the reviewers are simply busy. In either case, we ask for your understanding during the review process. For more information, see our FAQ on this topic: http://scikit-learn.org/dev/faq.html#why-is-my-pull-request-not-getting-any-attention. Thanks for contributing! --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/pipeline.py] (definition of Pipeline.__len__:) def __len__(self): """Returns the length of the Pipeline""" [end of new definitions in sklearn/pipeline.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Pipeline should implement __len__ #### Description With the new indexing support `pipe[:len(pipe)]` raises an error. #### Steps/Code to Reproduce ```python from sklearn import svm from sklearn.datasets import samples_generator from sklearn.feature_selection import SelectKBest from sklearn.feature_selection import f_regression from sklearn.pipeline import Pipeline # generate some data to play with X, y = samples_generator.make_classification( n_informative=5, n_redundant=0, random_state=42) anova_filter = SelectKBest(f_regression, k=5) clf = svm.SVC(kernel='linear') pipe = Pipeline([('anova', anova_filter), ('svc', clf)]) len(pipe) ``` #### Versions ``` System: python: 3.6.7 \| packaged by conda-forge \| (default, Feb 19 2019, 18:37:23) [GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)] executable: /Users/krisz/.conda/envs/arrow36/bin/python machine: Darwin-18.2.0-x86_64-i386-64bit BLAS: macros: HAVE_CBLAS=None lib_dirs: /Users/krisz/.conda/envs/arrow36/lib cblas_libs: openblas, openblas Python deps: pip: 19.0.3 setuptools: 40.8.0 sklearn: 0.21.dev0 numpy: 1.16.2 scipy: 1.2.1 Cython: 0.29.6 pandas: 0.24.1 ``` ---------- None should work just as well, but perhaps you're right that len should be implemented. I don't think we should implement other things from sequences such as iter, however. I think len would be good to have but I would also try to add as little as possible. +1 > I am looking at it. -------------------- </issues>	66cc1c7342f7f0cc0dc57fb6d56053fc46c8e5f0
sympy__sympy-16225	16,225	sympy/sympy	1.4	faad12d1307099aff62b559a84df40a999b8219c	2019-03-10T20:52:32Z	diff --git a/sympy/utilities/iterables.py b/sympy/utilities/iterables.py index de844583b5a9..64fa22caee65 100644 --- a/sympy/utilities/iterables.py +++ b/sympy/utilities/iterables.py @@ -1,6 +1,6 @@ from __future__ import print_function, division -from collections import defaultdict +from collections import defaultdict, OrderedDict from itertools import ( combinations, combinations_with_replacement, permutations, product, product as cartes @@ -929,6 +929,200 @@ def topological_sort(graph, key=None): return L +def strongly_connected_components(G): + r""" + Strongly connected components of a directed graph in reverse topological + order. + + + Parameters + ========== + + graph : tuple[list, list[tuple[T, T]] + A tuple consisting of a list of vertices and a list of edges of + a graph whose strongly connected components are to be found. + + + Examples + ======== + + Consider a directed graph (in dot notation):: + + digraph { + A -> B + A -> C + B -> C + C -> B + B -> D + } + + where vertices are the letters A, B, C and D. This graph can be encoded + using Python's elementary data structures as follows:: + + >>> V = ['A', 'B', 'C', 'D'] + >>> E = [('A', 'B'), ('A', 'C'), ('B', 'C'), ('C', 'B'), ('B', 'D')] + + The strongly connected components of this graph can be computed as + + >>> from sympy.utilities.iterables import strongly_connected_components + + >>> strongly_connected_components((V, E)) + [['D'], ['B', 'C'], ['A']] + + This also gives the components in reverse topological order. + + Since the subgraph containing B and C has a cycle they must be together in + a strongly connected component. A and D are connected to the rest of the + graph but not in a cyclic manner so they appear as their own strongly + connected components. + + + Notes + ===== + + The vertices of the graph must be hashable for the data structures used. + If the vertices are unhashable replace them with integer indices. + + This function uses Tarjan's algorithm to compute the strongly connected + components in `O(\|V\|+\|E\|)` (linear) time. + + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Strongly_connected_component + .. [2] https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm + + + See Also + ======== + + utilities.iterables.connected_components() + + """ + # Map from a vertex to its neighbours + V, E = G + Gmap = {vi: [] for vi in V} + for v1, v2 in E: + Gmap[v1].append(v2) + + # Non-recursive Tarjan's algorithm: + lowlink = {} + indices = {} + stack = OrderedDict() + callstack = [] + components = [] + nomore = object() + + def start(v): + index = len(stack) + indices[v] = lowlink[v] = index + stack[v] = None + callstack.append((v, iter(Gmap[v]))) + + def finish(v1): + # Finished a component? + if lowlink[v1] == indices[v1]: + component = [stack.popitem()[0]] + while component[-1] is not v1: + component.append(stack.popitem()[0]) + components.append(component[::-1]) + v2, _ = callstack.pop() + if callstack: + v1, _ = callstack[-1] + lowlink[v1] = min(lowlink[v1], lowlink[v2]) + + for v in V: + if v in indices: + continue + start(v) + while callstack: + v1, it1 = callstack[-1] + v2 = next(it1, nomore) + # Finished children of v1? + if v2 is nomore: + finish(v1) + # Recurse on v2 + elif v2 not in indices: + start(v2) + elif v2 in stack: + lowlink[v1] = min(lowlink[v1], indices[v2]) + + # Reverse topological sort order: + return components + + +def connected_components(G): + r""" + Connected components of an undirected graph or weakly connected components + of a directed graph. + + + Parameters + ========== + + graph : tuple[list, list[tuple[T, T]] + A tuple consisting of a list of vertices and a list of edges of + a graph whose connected components are to be found. + + + Examples + ======== + + + Given an undirected graph:: + + graph { + A -- B + C -- D + } + + We can find the connected components using this function if we include + each edge in both directions:: + + >>> from sympy.utilities.iterables import connected_components + + >>> V = ['A', 'B', 'C', 'D'] + >>> E = [('A', 'B'), ('B', 'A'), ('C', 'D'), ('D', 'C')] + >>> connected_components((V, E)) + [['A', 'B'], ['C', 'D']] + + The weakly connected components of a directed graph can found the same + way. + + + Notes + ===== + + The vertices of the graph must be hashable for the data structures used. + If the vertices are unhashable replace them with integer indices. + + This function uses Tarjan's algorithm to compute the connected components + in `O(\|V\|+\|E\|)` (linear) time. + + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Connected_component_(graph_theory) + .. [2] https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm + + + See Also + ======== + + utilities.iterables.strongly_connected_components() + + """ + # Duplicate edges both ways so that the graph is effectively undirected + # and return the strongly connected components: + V, E = G + E_undirected = [] + for v1, v2 in E: + E_undirected.extend([(v1, v2), (v2, v1)]) + return strongly_connected_components((V, E_undirected)) + + def rotate_left(x, y): """ Left rotates a list x by the number of steps specified	diff --git a/sympy/utilities/tests/test_iterables.py b/sympy/utilities/tests/test_iterables.py index a44fa6f51494..17fa2097d3ef 100644 --- a/sympy/utilities/tests/test_iterables.py +++ b/sympy/utilities/tests/test_iterables.py @@ -8,14 +8,15 @@ from sympy.core.compatibility import range from sympy.utilities.iterables import ( _partition, _set_partitions, binary_partitions, bracelets, capture, - cartes, common_prefix, common_suffix, dict_merge, filter_symbols, - flatten, generate_bell, generate_derangements, generate_involutions, - generate_oriented_forest, group, has_dups, ibin, kbins, minlex, multiset, - multiset_combinations, multiset_partitions, + cartes, common_prefix, common_suffix, connected_components, dict_merge, + filter_symbols, flatten, generate_bell, generate_derangements, + generate_involutions, generate_oriented_forest, group, has_dups, ibin, + kbins, minlex, multiset, multiset_combinations, multiset_partitions, multiset_permutations, necklaces, numbered_symbols, ordered, partitions, permutations, postfixes, postorder_traversal, prefixes, reshape, - rotate_left, rotate_right, runs, sift, subsets, take, topological_sort, - unflatten, uniq, variations, ordered_partitions, rotations) + rotate_left, rotate_right, runs, sift, strongly_connected_components, + subsets, take, topological_sort, unflatten, uniq, variations, + ordered_partitions, rotations) from sympy.utilities.enumerative import ( factoring_visitor, multiset_partitions_taocp ) @@ -241,6 +242,40 @@ def test_topological_sort(): raises(ValueError, lambda: topological_sort((V, E + [(10, 7)]))) +def test_strongly_connected_components(): + assert strongly_connected_components(([], [])) == [] + assert strongly_connected_components(([1, 2, 3], [])) == [[1], [2], [3]] + + V = [1, 2, 3] + E = [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1)] + assert strongly_connected_components((V, E)) == [[1, 2, 3]] + + V = [1, 2, 3, 4] + E = [(1, 2), (2, 3), (3, 2), (3, 4)] + assert strongly_connected_components((V, E)) == [[4], [2, 3], [1]] + + V = [1, 2, 3, 4] + E = [(1, 2), (2, 1), (3, 4), (4, 3)] + assert strongly_connected_components((V, E)) == [[1, 2], [3, 4]] + + +def test_connected_components(): + assert connected_components(([], [])) == [] + assert connected_components(([1, 2, 3], [])) == [[1], [2], [3]] + + V = [1, 2, 3] + E = [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1)] + assert connected_components((V, E)) == [[1, 2, 3]] + + V = [1, 2, 3, 4] + E = [(1, 2), (2, 3), (3, 2), (3, 4)] + assert connected_components((V, E)) == [[1, 2, 3, 4]] + + V = [1, 2, 3, 4] + E = [(1, 2), (3, 4)] + assert connected_components((V, E)) == [[1, 2], [3, 4]] + + def test_rotate(): A = [0, 1, 2, 3, 4]		[ { "components": [ { "doc": "Strongly connected components of a directed graph in reverse topological\norder.\n\n\nParameters\n==========\n\ngraph : tuple[list, list[tuple[T, T]]\n A tuple consisting of a list of vertices and a list of edges of\n a graph whose strongly connected components ar...	[ "test_postorder_traversal", "test_flatten", "test_group", "test_subsets", "test_variations", "test_cartes", "test_filter_symbols", "test_numbered_symbols", "test_sift", "test_take", "test_dict_merge", "test_prefixes", "test_postfixes", "test_topological_sort", "test_strongly_connected_co...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add connected_components function in iterables <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> Fixes #16174 #### Brief description of what is fixed or changed Adds a new function `connected_components` in sympy.utilities.iterables. The function can be used to find the connected components of a graph and is intended for internal use. #### Other comments As added here the function isn't used yet but I have other ideas for improvements in SymPy that would benefit from this function (as described in #16174 and #16207). #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> NO ENTRY <!-- END RELEASE NOTES --> ---------- FWIW: ```python def interpret_digraph(digraph): """ >>> v = var('a:f') >>> digraph = (a>b, a>c, Ne(b, c), b>d, c>f, f>b, b>e) >>> interpret_digraph(digraph) ({0: a, 1: b, 2: c, 3: d, 4: e, 5: f}, (0, 1, 2, 3, 4, 5), ((0, 1), (0, 2), (1, 2), (2, 1), (1, 3), (2, 5), (5, 1), (1, 4))) """ vertices = Tuple(list(ordered(Tuple(digraph).free_symbols))) edges = [] for line in digraph: if isinstance(line, Ne): edges.append(line.args) edges.append(line.reversed.args) elif isinstance(line, Gt): edges.append(line.args) elif isinstance(line, Lt): edges.append(line.reversed.args) m, unm = recast_to_ints(vertices) return unm, vertices.subs(m), Tuple(*edges).subs(m) def recast_to_ints(items): """ >>> recast_to_ints((1,3,4,2)) ({1: 0, 2: 3, 3: 1, 4: 2}, {0: 1, 1: 3, 2: 4, 3: 2}) >>> recast_to_ints((x,z,y)) ({x: 0, y: 2, z: 1}, {0: x, 1: z, 2: y}) """ u = list(uniq(items)) try: p= dict(zip(u, range(len(u)))) un = dict([(v, k) for k, v in p.items()]) return mapping except TypeError: p = [(i, items.index(i)) for i in range(len(u))] un = [(v, k) for k, v in p] return p, un ``` BTW, is this a prequel to better logic simplification? Also, if you ever need to work with repetitions, I have an #11196. Where did `interpret_digaph` come from? I wasn't aiming for logic simplification with this but I think @oscargus also had a suggestion involving this. My use case for this was evaluating summations (for cases where the limits depends on the other summation indexes), but logic simplification is always interesting. > Where did `interpret_digaph` come from? I just wrote it to use SymPy expressions to represent a digraph so `x>y` is for `x->y` and `Ne(x, y)` which could be entered in Python as `x<>y` was for the two-way connection. But I guess `Eq(x, y)` would be better since it prints without heads and `!=` or normal math variant is not indicative of a two-way connection. Should the name be `strongly_connected_components`? Or maybe there could be a keyword `strong`. In some cases, it could be desirable to find the actual (connected) components. It was originally called strongly_connected_components and then I changed it because you can use it to find weakly connected components and connected components as well: just include the edges both ways. If the function added here was called `strongly_connected_components` then ```python def strongly_connected_components(G): # The function added here. ... def weakly_connected_components(G): V, E = G E_undirected = [] for v1, v2 in E: E_undirected.extend((v1, v2), (v2, v1)) return strongly_connected_components((V, E_undirected)) def connected_components(G): return weakly_connected_components(G) ``` I could add those three function with these names. I wouldn't normally want to use the other functions though since most likely in any place you would use it duplicating the edges inside the `connected_components` function would also be duplicating the work done at the call site. On other hand a `connected_components` function with an independent implementation could probably have lower overhead than the one added here. I could do that instead if it doesn't seem like mission creep. I have realized that for my use case, `connected_components` is really what I need (assuming that means splitting a graph into connected subgraphs). Not really sure if I can do that here or with any of the alternatives. Basically, I need to find which symbols have an interdependence and in what order, so first split into subgraphs, then for each order them (where I thought that this solved, at least, the first problem). So `V = [a, b, c]`, `E = [(b, a)]` would return something like `[[b, a], [c]]` (I'm not saying that I want someone to write this for me, but I cannot really figure out if any of the options above can do that...) Yeah, so if you have an undirected graph (edges are symmetric) then connected_components is what you want. Maybe I should just add all three functions. There is directionality in the graph, but assuming that I can split it using this I can order it later. I think that it can be useful, yes. I also assume that separating sets of equations etc can be one use case. I do not know how the "repetitive substitution" works know but I assume that it may be that one can order the equations in a more sensible way using this (and split into independent sets of equations to solve in case that happens). I do not really think overhead is a problem here. At least not for the cases I am considering. And since it is asymptotically linear it should be marginal improvements anyway. (If it is, one can write a specialized version later...) I've changed this to two functions `strongly_connected_components` and `connected_components` (which uses the former as its implementation). </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/utilities/iterables.py] (definition of strongly_connected_components:) def strongly_connected_components(G): """Strongly connected components of a directed graph in reverse topological order. Parameters ========== graph : tuple[list, list[tuple[T, T]] A tuple consisting of a list of vertices and a list of edges of a graph whose strongly connected components are to be found. Examples ======== Consider a directed graph (in dot notation):: digraph { A -> B A -> C B -> C C -> B B -> D } where vertices are the letters A, B, C and D. This graph can be encoded using Python's elementary data structures as follows:: >>> V = ['A', 'B', 'C', 'D'] >>> E = [('A', 'B'), ('A', 'C'), ('B', 'C'), ('C', 'B'), ('B', 'D')] The strongly connected components of this graph can be computed as >>> from sympy.utilities.iterables import strongly_connected_components >>> strongly_connected_components((V, E)) [['D'], ['B', 'C'], ['A']] This also gives the components in reverse topological order. Since the subgraph containing B and C has a cycle they must be together in a strongly connected component. A and D are connected to the rest of the graph but not in a cyclic manner so they appear as their own strongly connected components. Notes ===== The vertices of the graph must be hashable for the data structures used. If the vertices are unhashable replace them with integer indices. This function uses Tarjan's algorithm to compute the strongly connected components in `O(\|V\|+\|E\|)` (linear) time. References ========== .. [1] https://en.wikipedia.org/wiki/Strongly_connected_component .. [2] https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm See Also ======== utilities.iterables.connected_components()""" (definition of strongly_connected_components.start:) def start(v): (definition of strongly_connected_components.finish:) def finish(v1): (definition of connected_components:) def connected_components(G): """Connected components of an undirected graph or weakly connected components of a directed graph. Parameters ========== graph : tuple[list, list[tuple[T, T]] A tuple consisting of a list of vertices and a list of edges of a graph whose connected components are to be found. Examples ======== Given an undirected graph:: graph { A -- B C -- D } We can find the connected components using this function if we include each edge in both directions:: >>> from sympy.utilities.iterables import connected_components >>> V = ['A', 'B', 'C', 'D'] >>> E = [('A', 'B'), ('B', 'A'), ('C', 'D'), ('D', 'C')] >>> connected_components((V, E)) [['A', 'B'], ['C', 'D']] The weakly connected components of a directed graph can found the same way. Notes ===== The vertices of the graph must be hashable for the data structures used. If the vertices are unhashable replace them with integer indices. This function uses Tarjan's algorithm to compute the connected components in `O(\|V\|+\|E\|)` (linear) time. References ========== .. [1] https://en.wikipedia.org/wiki/Connected_component_(graph_theory) .. [2] https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm See Also ======== utilities.iterables.strongly_connected_components()""" [end of new definitions in sympy/utilities/iterables.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Graph theoretic algorithms for internal use (e.g. Tarjan's algorithm) I have thought of a couple of patches that would benefit from having algorithms for e.g. finding connected components of a graph. Do any graphs theoretic algorithms exist anywhere for internal use in SymPy? I see #8186 rejects the idea of adding a graph theory module for external use but this is about internal use. I have two examples: 1. Given a system of ODEs we can define a directed graph where the variables are the vertices and an equation involving f_i(x).diff(x) and f_j(x) is an edge from i to j. The weakly connected components of this graph represent subsets of the system of equations that can be solved independently. The strongly connected components represent the coupled systems of ODEs that have to be solved as units. 2. Eigenvalues of block diagonal or block diagonal permuted matrices. Viewing a matrix as an adjacency matrix we can partition the row/col indices into ~strongly~ connected components. Those ~strongly~ connected components can be solved as reduced problems in a divide and conquer style approach. This would give a significant performance boost for many matrices. For these two it would be useful to have e.g. Tarjan's algorithm: [https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm](https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm) I'm opening this issue to ask: 1. Does this already exist in SymPy? 2. If not is there a good place to put it? 3. Are there other parts of SymPy that could benefit from something like this? ---------- We have `topological_sort`, which is useful in several places. If a graph algorithm is needed for some library code we should implement it. Tarjan's algorithm, like the topological sort algorithm, doesn't seem that complicated, but it would be useful to implement it in one place. Can the algorithm you describe for ODEs apply to solving regular systems of equations as well? It could be used for regular systems of equations but there we would have undirected graphs. So the idea would be that given ``` a + b = 2 a - b = 1 c + d = 1 c - d = 2 ``` we could partition that into two subproblems for (a,b) and (c,d). I'm not sure how useful that wold be or if it already happens. In the case of ODEs we can do the same but we can also go a step further since for ODEs we have a directed graph so given: ``` f(t).diff(t) = 1 g(t).diff(t) = f(t) + h(t) h(t).diff(t) = g(t) + f(t) z(t).diff(t) = h(t) ``` We can identify that (g,h) is a strongly connected component that must be solved as a unit. The variable f is not disconnected from the graph but is not in a strongly connected component with any other variables so that ODE can be solved independently. Once we've solved for f we can eliminate it from the equations for g,h. Then they can be solved as a separate system. Once we have the solution for h the equation for z becomes a single ODE that can be solved independently. For the ODE module this could greatly expand the number of systems that are matched since we only need to match the strongly connected components of the system. Making use of it needs good support for non-homogeneous / non-autonomous systems though. Ah. So this actually combines nicely with topological_sort, since the strongly connected components create a DAG. The topological_sort tells you what order to solve the sub-systems in. Although apparently Tarjan's algorithm already returns the components in (reverse) topological order). I suspect many places that use topological_sort could be using this instead, as a more generalized way to handle graphs with cycles. For example you can topologically sort a substitution, to make it happen "in order". https://github.com/sympy/sympy/issues/6257 If there's a cycle, like `expr.subs({x: y, y: z})`, it fails. But maybe this can be generalized to finding the strongly connected components and substituting each strongly connected component with simultaneous=True, doing each component in topological order. I would describe `expr.subs({x: y, y: z})` as a chain rather than a cycle. We could certainly partition the substitutions into strongly connected components. Would those components be unambiguous though. What about something where one replacement expression appear in another e.g. `expr.subs({x:y, exp(x):z})`? I think something similar can be used when evaluating summations with symbols in the limits, see #15767 where one approach is to reorder the summation order. (Which will not solve the issue at hand, but still can be useful if deciding to do an explicit evaluation as it may split it into several independent summations/evaluations.) Edit: and therefore also integrals with symbols in the limits, although I do not know if there is a similar issue there. > We could certainly partition the substitutions into strongly connected components. Would those components be unambiguous though. What about something where one replacement expression appear in another e.g. expr.subs({x:y, exp(x):z})? I hadn't thought about that. Maybe you would also need an edge if one term's "old" also contains another's. I'm mostly thinking out loud with this idea. I don't know if it is a good one, just trying to think of ways this algorithm could be useful. Here's an implementation of Tarjan's algorithm: ```python def strongly_connected_components(vertices, edgefunc): '''Strongly connected components of a graph vertices is an iterable giving the vertices of the graph. edgefunc(vertex) gives an iterable of vertices that have edges from vertex. ''' def follow(v1): # Add to the data structures index = len(stack) indices[v1] = lowlink[v1] = index stack.append(v1) # Recurse over descendants for v2 in edgefunc(v1): if v2 not in indices: follow(v2) lowlink[v1] = min(lowlink[v1], lowlink[v2]) elif v2 in stack: lowlink[v1] = min(lowlink[v1], indices[v2]) # Pop off complete connected components if lowlink[v1] == indices[v1]: component = [stack.pop()] while component[-1] is not v1: component.append(stack.pop()) components.append(component[::-1]) lowlink = {} indices = {} stack = [] components = [] for v in vertices: if v in indices: continue follow(v) return components # This represents a directed graph which in dot notation would look like: # digraph G { # A -> B # A -> C # A -> D # B -> C # C -> B # C -> D # } graph = { 'A': ('B', 'C', 'D'), 'B': ('C'), 'C': ('B', 'D'), 'D': (), } for c in strongly_connected_components(graph, graph.__getitem__): print(c) ``` Output: ```console $ python scc.py ['D'] ['B', 'C'] ['A'] ``` Can it use the same input format as topological_sort. Input format is one thing that a real graph library like networkx will provide more flexibility over, but we should just pick a format that is convenient and use it. Is `min` called over integers or over graph elements? If it's graph elements we should allow to pass a `key` function to it. > Cain it use the same input format as topological_sort. Input format can be easily changed. > Is min called over integers or over graph elements? If it's graph elements we should allow to pass a key > function to it. It is called over integers. Here's a version that takes the same format as topological_sort: ```python from sympy import * def strongly_connected_components(G): '''Strongly connected components of a graph G is a tuple (V, E) with V the vertices and E the edges as (v1, v2) pairs. ''' V, E = G Gmap = {vi: [] for vi in V} for v1, v2 in E: Gmap[v1].append(v2) def follow(v1): # Add to the data structures index = len(stack) indices[v1] = lowlink[v1] = index stack.append(v1) # Recurse over descendants for v2 in Gmap[v1]: if v2 not in indices: follow(v2) lowlink[v1] = min(lowlink[v1], lowlink[v2]) elif v2 in stack: lowlink[v1] = min(lowlink[v1], indices[v2]) # Pop off complete connected components if lowlink[v1] == indices[v1]: component = [stack.pop()] while component[-1] is not v1: component.append(stack.pop()) components.append(component[::-1]) lowlink = {} indices = {} stack = [] components = [] for vi in V: if vi in indices: continue follow(vi) return components # This represents a directed graph which in dot notation would look like: # digraph G { # A -> B # A -> C # A -> D # B -> C # C -> B # C -> D # } V = ['A', 'B', 'C', 'D'] E = [ ('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'C'), ('C', 'B'), ('C', 'D'), ] G = (V, E) for c in strongly_connected_components(G): print(c) ``` Here's an example of how we could use this in solve to partition a system of equations (this is an undirected graph so we're just finding the connected components). The function solve_scc solves a system of equations by first partitioning the system into connected components and is faster than solve. ```python def solve_scc(eqs, syms): # Build graph V = syms E = [] # Map back from syms to eqs eqmap = {s:set() for s in syms} for eq in eqs: eqsyms = eq.free_symbols & set(syms) for s1 in eqsyms: eqmap[s1].add(eq) for s2 in eqsyms: if s1 is s2: break E.append((s1, s2)) E.append((s2, s1)) G = (V, E) # Find coupled subsystems: coupled_syms = strongly_connected_components(G) # Solve subsystems and combine results soldict = {} for csyms in coupled_syms: ceqs = set.union([eqmap[s] for s in csyms]) csol = solve(ceqs, csyms, dict=True) assert len(csol) == 1 soldict.update(csol[0]) return [soldict] # Build a big-ish linear system: Nrep = 5 # Nrep3 equations syms = symbols('x:%d' % (3Nrep,)) a, b, c = symbols('a b c') B = Matrix([ [a, b, c], [a, -b, c], [a, b, -c], ]) rhs = [1, 2, 3] Nrep M = BlockMatrix([[B if i == j else zeros(3, 3) for i in range(Nrep)] for j in range(Nrep)]) M = M.as_explicit() #pprint(M) b = Matrix([[bi] for bi in rhs]) x = Matrix([[si] for si in syms]) eqs = list(Mx - b) #pprint(eqs) import time # Solve with scc_solve: start = time.time() sol_scc = solve_scc(eqs, syms) print('solve_scc:', time.time() - start, 'seconds') # Solve with solve: start = time.time() sol = solve(eqs, syms, dict=True) print('solve:', time.time() - start, 'seconds') ``` Running this the timings are: ```console $ python scc.py solve_scc: 0.47367119789123535 seconds solve: 35.56143808364868 seconds ``` The differences grow as a system like this gets larger (increase Nrep). Solving an NxN linear system is maybe `O(N3)`. Here we trade a single system of size N for k systems of size N/k which is then `O(N3/k*2)`. So the improvement is quadratic in the number of subsystems that we can break down to. I think it would make sense to add strongly_connected_components. We both have usecases for it, so go ahead, I would say! -------------------- </issues>	e941ad69638189ea42507331e417b88837357dec
sympy__sympy-16221	16,221	sympy/sympy	1.4	8fc3b3a96b9f982ed6dc8f626129abee36bcda95	2019-03-10T09:11:58Z	diff --git a/sympy/printing/mathematica.py b/sympy/printing/mathematica.py index ca6ab2f556cb..fd01f493a691 100644 --- a/sympy/printing/mathematica.py +++ b/sympy/printing/mathematica.py @@ -160,6 +160,55 @@ def print_dims(): return 'SparseArray[{}, {}]'.format(print_data(), print_dims()) + def _print_ImmutableDenseNDimArray(self, expr): + return self.doprint(expr.tolist()) + + def _print_ImmutableSparseNDimArray(self, expr): + def print_string_list(string_list): + return '{' + ', '.join(a for a in string_list) + '}' + + def to_mathematica_index(args): + """Helper function to change Python style indexing to + Pathematica indexing. + + Python indexing (0, 1 ... n-1) + -> Mathematica indexing (1, 2 ... n) + """ + return tuple(i + 1 for i in args) + + def print_rule(pos, val): + """Helper function to print a rule of Mathematica""" + return '{} -> {}'.format(self.doprint(pos), self.doprint(val)) + + def print_data(): + """Helper function to print data part of Mathematica + sparse array. + + It uses the fourth notation ``SparseArray[data,{d1,d2,…}]`` + from + https://reference.wolfram.com/language/ref/SparseArray.html + + ``data`` must be formatted with rule. + """ + return print_string_list( + [print_rule( + to_mathematica_index((expr._get_tuple_index(key))), + value) + for key, value in sorted(expr._sparse_array.items())] + ) + + def print_dims(): + """Helper function to print dimensions part of Mathematica + sparse array. + + It uses the fourth notation ``SparseArray[data,{d1,d2,…}]`` + from + https://reference.wolfram.com/language/ref/SparseArray.html + """ + return self.doprint(expr.shape) + + return 'SparseArray[{}, {}]'.format(print_data(), print_dims()) + def _print_Function(self, expr): if expr.func.__name__ in self.known_functions: cond_mfunc = self.known_functions[expr.func.__name__]	diff --git a/sympy/printing/tests/test_mathematica.py b/sympy/printing/tests/test_mathematica.py index 6f2210f51ddb..ad7658b2fd47 100644 --- a/sympy/printing/tests/test_mathematica.py +++ b/sympy/printing/tests/test_mathematica.py @@ -113,6 +113,58 @@ def test_matrices(): assert mcode(MutableDenseMatrix(3, 0, [])) == '{{}, {}, {}}' assert mcode(MutableSparseMatrix(3, 0, [])) == 'SparseArray[{}, {3, 0}]' +def test_NDArray(): + from sympy.tensor.array import ( + MutableDenseNDimArray, ImmutableDenseNDimArray, + MutableSparseNDimArray, ImmutableSparseNDimArray) + + example = MutableDenseNDimArray( + [[[1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12]], + [[13, 14, 15, 16], + [17, 18, 19, 20], + [21, 22, 23, 24]]] + ) + + assert mcode(example) == \ + "{{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}, " \ + "{{13, 14, 15, 16}, {17, 18, 19, 20}, {21, 22, 23, 24}}}" + + example = ImmutableDenseNDimArray(example) + + assert mcode(example) == \ + "{{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}, " \ + "{{13, 14, 15, 16}, {17, 18, 19, 20}, {21, 22, 23, 24}}}" + + example = MutableSparseNDimArray(example) + + assert mcode(example) == \ + "SparseArray[{" \ + "{1, 1, 1} -> 1, {1, 1, 2} -> 2, {1, 1, 3} -> 3, " \ + "{1, 1, 4} -> 4, {1, 2, 1} -> 5, {1, 2, 2} -> 6, " \ + "{1, 2, 3} -> 7, {1, 2, 4} -> 8, {1, 3, 1} -> 9, " \ + "{1, 3, 2} -> 10, {1, 3, 3} -> 11, {1, 3, 4} -> 12, " \ + "{2, 1, 1} -> 13, {2, 1, 2} -> 14, {2, 1, 3} -> 15, " \ + "{2, 1, 4} -> 16, {2, 2, 1} -> 17, {2, 2, 2} -> 18, " \ + "{2, 2, 3} -> 19, {2, 2, 4} -> 20, {2, 3, 1} -> 21, " \ + "{2, 3, 2} -> 22, {2, 3, 3} -> 23, {2, 3, 4} -> 24" \ + "}, {2, 3, 4}]" + + example = ImmutableSparseNDimArray(example) + + assert mcode(example) == \ + "SparseArray[{" \ + "{1, 1, 1} -> 1, {1, 1, 2} -> 2, {1, 1, 3} -> 3, " \ + "{1, 1, 4} -> 4, {1, 2, 1} -> 5, {1, 2, 2} -> 6, " \ + "{1, 2, 3} -> 7, {1, 2, 4} -> 8, {1, 3, 1} -> 9, " \ + "{1, 3, 2} -> 10, {1, 3, 3} -> 11, {1, 3, 4} -> 12, " \ + "{2, 1, 1} -> 13, {2, 1, 2} -> 14, {2, 1, 3} -> 15, " \ + "{2, 1, 4} -> 16, {2, 2, 1} -> 17, {2, 2, 2} -> 18, " \ + "{2, 2, 3} -> 19, {2, 2, 4} -> 20, {2, 3, 1} -> 21, " \ + "{2, 3, 2} -> 22, {2, 3, 3} -> 23, {2, 3, 4} -> 24" \ + "}, {2, 3, 4}]" + def test_Integral(): assert mcode(Integral(sin(sin(x)), x)) == "Hold[Integrate[Sin[Sin[x]], x]]"		[ { "components": [ { "doc": "", "lines": [ 163, 164 ], "name": "MCodePrinter._print_ImmutableDenseNDimArray", "signature": "def _print_ImmutableDenseNDimArray(self, expr):", "type": "function" }, { "doc": "", "l...	[ "test_NDArray" ]	[ "test_Integer", "test_Rational", "test_Function", "test_Pow", "test_Mul", "test_constants", "test_containers", "test_matrices", "test_Integral", "test_Derivative", "test_Sum" ]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Printing : N-Dimensional Array for Mathematica <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> Fixes #15618 #### Brief description of what is fixed or changed Finally, I have added NDArrays for mathematica printers. Though some helper functions are duplicate to the implementation in #15792, I left some boilerplates before any good way to support Mathematica's rules system, strings, or such are discovered. Reference for mathematica sparse array https://reference.wolfram.com/language/ref/SparseArray.html #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - printing - Added support for `DenseNDimArray` and `SparseNDimArray` for `mathematica_code` <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/printing/mathematica.py] (definition of MCodePrinter._print_ImmutableDenseNDimArray:) def _print_ImmutableDenseNDimArray(self, expr): (definition of MCodePrinter._print_ImmutableSparseNDimArray:) def _print_ImmutableSparseNDimArray(self, expr): (definition of MCodePrinter._print_ImmutableSparseNDimArray.print_string_list:) def print_string_list(string_list): (definition of MCodePrinter._print_ImmutableSparseNDimArray.to_mathematica_index:) def to_mathematica_index(*args): """Helper function to change Python style indexing to Pathematica indexing. Python indexing (0, 1 ... n-1) -> Mathematica indexing (1, 2 ... n)""" (definition of MCodePrinter._print_ImmutableSparseNDimArray.print_rule:) def print_rule(pos, val): """Helper function to print a rule of Mathematica""" (definition of MCodePrinter._print_ImmutableSparseNDimArray.print_data:) def print_data(): """Helper function to print data part of Mathematica sparse array. It uses the fourth notation ``SparseArray[data,{d1,d2,…}]`` from https://reference.wolfram.com/language/ref/SparseArray.html ``data`` must be formatted with rule.""" (definition of MCodePrinter._print_ImmutableSparseNDimArray.print_dims:) def print_dims(): """Helper function to print dimensions part of Mathematica sparse array. It uses the fourth notation ``SparseArray[data,{d1,d2,…}]`` from https://reference.wolfram.com/language/ref/SparseArray.html""" [end of new definitions in sympy/printing/mathematica.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Mathematica code: allow printing of matrices and arrays. Our printers for Wolfram Mathematica do not support matrices and arrays. We should add support for it. ---------- -------------------- </issues>	e941ad69638189ea42507331e417b88837357dec
sympy__sympy-16209	16,209	sympy/sympy	1.4	00252f18af78cdc3013042e7ef264af8161c9366	2019-03-09T09:07:04Z	diff --git a/sympy/matrices/matrices.py b/sympy/matrices/matrices.py index b0efd9dc4278..d44f73ae4dc8 100644 --- a/sympy/matrices/matrices.py +++ b/sympy/matrices/matrices.py @@ -4260,6 +4260,100 @@ def QRsolve(self, b): x.append(tmp / R[j, j]) return self._new([row._mat for row in reversed(x)]) + def rank_decomposition(self, iszerofunc=_iszero, simplify=False): + r"""Returns a pair of matrices (`C`, `F`) with matching rank + such that `A = C F`. + + Parameters + ========== + + iszerofunc : Function, optional + A function used for detecting whether an element can + act as a pivot. ``lambda x: x.is_zero`` is used by default. + + simplify : Bool or Function, optional + A function used to simplify elements when looking for a + pivot. By default SymPy's ``simplify`` is used. + + Returns + ======= + + (C, F) : Matrices + `C` and `F` are full-rank matrices with rank as same as `A`, + whose product gives `A`. + + See Notes for additional mathematical details. + + Examples + ======== + + >>> from sympy.matrices import Matrix + >>> A = Matrix([ + ... [1, 3, 1, 4], + ... [2, 7, 3, 9], + ... [1, 5, 3, 1], + ... [1, 2, 0, 8] + ... ]) + >>> C, F = A.rank_decomposition() + >>> C + Matrix([ + [1, 3, 4], + [2, 7, 9], + [1, 5, 1], + [1, 2, 8]]) + >>> F + Matrix([ + [1, 0, -2, 0], + [0, 1, 1, 0], + [0, 0, 0, 1]]) + >>> C * F == A + True + + Notes + ===== + + Obtaining `F`, an RREF of `A`, is equivalent to creating a + product + + .. math:: + E_n E_{n-1} ... E_1 A = F + + where `E_n, E_{n-1}, ... , E_1` are the elimination matrices or + permutation matrices equivalent to each row-reduction step. + + The inverse of the same product of elimination matrices gives + `C`: + + .. math:: + C = (E_n E_{n-1} ... E_1)^{-1} + + It is not necessary, however, to actually compute the inverse: + the columns of `C` are those from the original matrix with the + same column indices as the indices of the pivot columns of `F`. + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Rank_factorization + + .. [2] Piziak, R.; Odell, P. L. (1 June 1999). + "Full Rank Factorization of Matrices". + Mathematics Magazine. 72 (3): 193. doi:10.2307/2690882 + + See Also + ======== + + rref + """ + (F, pivot_cols) = self.rref( + simplify=simplify, iszerofunc=iszerofunc, pivots=True) + rank = len(pivot_cols) + + C = self.extract(range(self.rows), pivot_cols) + F = F[:rank, :] + + return (C, F) + def solve_least_squares(self, rhs, method='CH'): """Return the least-square fit to the data.	diff --git a/sympy/matrices/tests/test_matrices.py b/sympy/matrices/tests/test_matrices.py index f6f78c6e22d8..fc8d49a4ff35 100644 --- a/sympy/matrices/tests/test_matrices.py +++ b/sympy/matrices/tests/test_matrices.py @@ -3304,6 +3304,34 @@ def test_iszero_substitution(): # if a zero-substitution wasn't made, this entry will be -1.11022302462516e-16 assert m_rref[2,2] == 0 +def test_rank_decomposition(): + a = Matrix(0, 0, []) + c, f = a.rank_decomposition() + assert f.is_echelon + assert c.cols == f.rows == a.rank() + assert c * f == a + + a = Matrix(1, 1, [5]) + c, f = a.rank_decomposition() + assert f.is_echelon + assert c.cols == f.rows == a.rank() + assert c * f == a + + a = Matrix(3, 3, [1, 2, 3, 1, 2, 3, 1, 2, 3]) + c, f = a.rank_decomposition() + assert f.is_echelon + assert c.cols == f.rows == a.rank() + assert c * f == a + + a = Matrix([ + [0, 0, 1, 2, 2, -5, 3], + [-1, 5, 2, 2, 1, -7, 5], + [0, 0, -2, -3, -3, 8, -5], + [-1, 5, 0, -1, -2, 1, 0]]) + c, f = a.rank_decomposition() + assert f.is_echelon + assert c.cols == f.rows == a.rank() + assert c * f == a @slow def test_issue_11238():		[ { "components": [ { "doc": "Returns a pair of matrices (`C`, `F`) with matching rank\nsuch that `A = C F`.\n\nParameters\n==========\n\niszerofunc : Function, optional\n A function used for detecting whether an element can\n act as a pivot. ``lambda x: x.is_zero`` is used by default.\n\nsim...	[ "test_rank_decomposition" ]	[ "test_args", "test_division", "test_sum", "test_abs", "test_addition", "test_fancy_index_matrix", "test_multiplication", "test_power", "test_creation", "test_tolist", "test_as_mutable", "test_determinant", "test_slicing", "test_submatrix_assignment", "test_extract", "test_reshape", "...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Matrices : Add rank factorization <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed https://en.wikipedia.org/wiki/Rank_factorization Similarly to gaussian elimination introducing LU decomposition, gauss-jordan elimination introduces rank decomposition, and it can be easily computed by taking the pivot columns of the original matrix. Though I rarely see this feature implemented in most computer algebra or numeric analysis softwares. I have added under `MatrixReductions` class, but still I think most of the decomposition methods are uncategorized in `MatrixBase`. <img src=https://user-images.githubusercontent.com/34944973/54493462-ba480880-4913-11e9-91ff-6b869a3654f9.png width="512px"> #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - matrices - Added a new function ``rank_decomposition``. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/matrices/matrices.py] (definition of MatrixBase.rank_decomposition:) def rank_decomposition(self, iszerofunc=_iszero, simplify=False): """Returns a pair of matrices (`C`, `F`) with matching rank such that `A = C F`. Parameters ========== iszerofunc : Function, optional A function used for detecting whether an element can act as a pivot. ``lambda x: x.is_zero`` is used by default. simplify : Bool or Function, optional A function used to simplify elements when looking for a pivot. By default SymPy's ``simplify`` is used. Returns ======= (C, F) : Matrices `C` and `F` are full-rank matrices with rank as same as `A`, whose product gives `A`. See Notes for additional mathematical details. Examples ======== >>> from sympy.matrices import Matrix >>> A = Matrix([ ... [1, 3, 1, 4], ... [2, 7, 3, 9], ... [1, 5, 3, 1], ... [1, 2, 0, 8] ... ]) >>> C, F = A.rank_decomposition() >>> C Matrix([ [1, 3, 4], [2, 7, 9], [1, 5, 1], [1, 2, 8]]) >>> F Matrix([ [1, 0, -2, 0], [0, 1, 1, 0], [0, 0, 0, 1]]) >>> C * F == A True Notes ===== Obtaining `F`, an RREF of `A`, is equivalent to creating a product .. math:: E_n E_{n-1} ... E_1 A = F where `E_n, E_{n-1}, ... , E_1` are the elimination matrices or permutation matrices equivalent to each row-reduction step. The inverse of the same product of elimination matrices gives `C`: .. math:: C = (E_n E_{n-1} ... E_1)^{-1} It is not necessary, however, to actually compute the inverse: the columns of `C` are those from the original matrix with the same column indices as the indices of the pivot columns of `F`. References ========== .. [1] https://en.wikipedia.org/wiki/Rank_factorization .. [2] Piziak, R.; Odell, P. L. (1 June 1999). "Full Rank Factorization of Matrices". Mathematics Magazine. 72 (3): 193. doi:10.2307/2690882 See Also ======== rref""" [end of new definitions in sympy/matrices/matrices.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		e941ad69638189ea42507331e417b88837357dec
joke2k__faker-919	919	joke2k/faker	null	9649c8d86e0baf8bc4fd33ba8661847ec33a62e1	2019-03-08T12:26:15Z	diff --git a/faker/providers/ssn/pt_BR/__init__.py b/faker/providers/ssn/pt_BR/__init__.py index 028637f21d..01e33307a1 100644 --- a/faker/providers/ssn/pt_BR/__init__.py +++ b/faker/providers/ssn/pt_BR/__init__.py @@ -1,6 +1,7 @@ # coding=utf-8 from __future__ import unicode_literals + from .. import Provider as SsnProvider @@ -44,3 +45,22 @@ def ssn(self): def cpf(self): c = self.ssn() return c[:3] + '.' + c[3:6] + '.' + c[6:9] + '-' + c[9:] + + def rg(self): + """ + Brazilian RG, return plain numbers. + Check: https://www.ngmatematica.com/2014/02/como-determinar-o-digito-verificador-do.html + """ + + digits = self.generator.random.sample(range(0, 9), 8) + checksum = sum(i * digits[i - 2] for i in range(2, 10)) + last_digit = 11 - (checksum % 11) + + if last_digit == 10: + digits.append('X') + elif last_digit == 11: + digits.append(0) + else: + digits.append(last_digit) + + return ''.join(map(str, digits))	diff --git a/tests/providers/test_ssn.py b/tests/providers/test_ssn.py index 0e09f3f895..1955ae60c7 100644 --- a/tests/providers/test_ssn.py +++ b/tests/providers/test_ssn.py @@ -423,6 +423,14 @@ def test_pt_BR_cpf(self): for _ in range(100): assert re.search(r'\d{3}\.\d{3}\.\d{3}-\d{2}', self.factory.cpf()) + def test_pt_BR_rg(self): + for _ in range(100): + to_test = self.factory.rg() + if 'X' in to_test: + assert re.search(r'^\d{8}X', to_test) + else: + assert re.search(r'^\d{9}$', to_test) + class TestNlNL(unittest.TestCase): def setUp(self):		[ { "components": [ { "doc": "Brazilian RG, return plain numbers.\nCheck: https://www.ngmatematica.com/2014/02/como-determinar-o-digito-verificador-do.html", "lines": [ 49, 66 ], "name": "Provider.rg", "signature": "def rg(self):", "type":...	[ "tests/providers/test_ssn.py::TestPtBR::test_pt_BR_rg" ]	[ "tests/providers/test_ssn.py::TestBgBG::test_vat_id", "tests/providers/test_ssn.py::TestCsCZ::test_vat_id", "tests/providers/test_ssn.py::TestDeAT::test_vat_id", "tests/providers/test_ssn.py::TestElCY::test_vat_id", "tests/providers/test_ssn.py::TestEnCA::test_ssn", "tests/providers/test_ssn.py::TestEnUS:...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Brazilian RG Feature ### What does this changes Address Brazilian RG (identity card) ### What was wrong New feature ### How this fixes it Fixes #918 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/ssn/pt_BR/__init__.py] (definition of Provider.rg:) def rg(self): """Brazilian RG, return plain numbers. Check: https://www.ngmatematica.com/2014/02/como-determinar-o-digito-verificador-do.html""" [end of new definitions in faker/providers/ssn/pt_BR/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Brazilian RG (identity card) Add Generator to Brazilian RG (identity card) ### Steps to reproduce fake = Faker('pt_Br') fake.rg() ### Expected behavior return like this rules: https://www.ngmatematica.com/2014/02/como-determinar-o-digito-verificador-do.html 8 digits + 1 checksum digit ### Actual behavior New feature ---------- -------------------- </issues>	6edfdbf6ae90b0153309e3bf066aa3b2d16494a7
sympy__sympy-16199	16,199	sympy/sympy	1.4	34482a7071422e5766a16a0370fa12f9a0b7c8e0	2019-03-08T06:00:41Z	diff --git a/sympy/vector/__init__.py b/sympy/vector/__init__.py index fccb4e4d14a1..2493bff5c945 100644 --- a/sympy/vector/__init__.py +++ b/sympy/vector/__init__.py @@ -13,4 +13,4 @@ from sympy.vector.point import Point from sympy.vector.orienters import (AxisOrienter, BodyOrienter, SpaceOrienter, QuaternionOrienter) -from sympy.vector.operators import Gradient, Divergence, Curl, gradient, curl, divergence +from sympy.vector.operators import Gradient, Divergence, Curl, Laplacian, gradient, curl, divergence diff --git a/sympy/vector/functions.py b/sympy/vector/functions.py index 574ec39f11e2..fb7f1ead08e1 100644 --- a/sympy/vector/functions.py +++ b/sympy/vector/functions.py @@ -198,6 +198,7 @@ def laplacian(expr): 2R.i + 6R.yR.j + 12R.z*2R.k """ + delop = Del() if expr.is_Vector: return (gradient(divergence(expr)) - curl(curl(expr))).doit() diff --git a/sympy/vector/operators.py b/sympy/vector/operators.py index 72231fa1d581..bc677f5e60c6 100644 --- a/sympy/vector/operators.py +++ b/sympy/vector/operators.py @@ -327,6 +327,32 @@ def gradient(scalar_field, coord_sys=None, doit=True): return Gradient(scalar_field) +class Laplacian(Expr): + """ + Represents unevaluated Laplacian. + + Examples + ======== + + >>> from sympy.vector import CoordSys3D, Laplacian + >>> R = CoordSys3D('R') + >>> v = 3R.x3R.y*2R.z*3 + >>> Laplacian(v) + Laplacian(3R.x*3R.y*2R.z3) + + """ + + def __new__(cls, expr): + expr = sympify(expr) + obj = Expr.__new__(cls, expr) + obj._expr = expr + return obj + + def doit(self, kwargs): + from sympy.vector.functions import laplacian + return laplacian(self._expr) + + def _diff_conditional(expr, base_scalar, coeff_1, coeff_2): """ First re-expresses expr in the system that base_scalar belongs to.	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 5895f1ca842c..2228bea932bd 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -4522,6 +4522,13 @@ def test_sympy__vector__operators__Curl(): assert _test_args(Curl(C.i)) +def test_sympy__vector__operators__Laplacian(): + from sympy.vector.operators import Laplacian + from sympy.vector.coordsysrect import CoordSys3D + C = CoordSys3D('C') + assert _test_args(Laplacian(C.i)) + + def test_sympy__vector__operators__Divergence(): from sympy.vector.operators import Divergence from sympy.vector.coordsysrect import CoordSys3D diff --git a/sympy/vector/tests/test_operators.py b/sympy/vector/tests/test_operators.py index 0ec64fe17377..236298f64eda 100644 --- a/sympy/vector/tests/test_operators.py +++ b/sympy/vector/tests/test_operators.py @@ -1,11 +1,13 @@ -from sympy.vector import CoordSys3D, Gradient, Divergence, Curl, VectorZero - +from sympy.vector import CoordSys3D, Gradient, Divergence, Curl, VectorZero, Laplacian +from sympy.printing.repr import srepr R = CoordSys3D('R') s1 = R.xR.yR.z s2 = R.x + 3R.y2 +s3 = R.x2 + R.y2 + R.z2 v1 = R.xR.i + R.zR.zR.j v2 = R.xR.i + R.yR.j + R.zR.k +v3 = R.x2R.i + R.y*2R.j + R.z*2R.k def test_Gradient(): @@ -27,3 +29,12 @@ def test_Curl(): assert Curl(v2) == Curl(R.xR.i + R.yR.j + R.zR.k) assert Curl(v1).doit() == (-2R.z)R.i assert Curl(v2).doit() == VectorZero() + + +def test_Laplacian(): + assert Laplacian(s3) == Laplacian(R.x2 + R.y2 + R.z2) + assert Laplacian(v3) == Laplacian(R.x2R.i + R.y*2R.j + R.z*2R.k) + assert Laplacian(s3).doit() == 6 + assert Laplacian(v3).doit() == 2R.i + 2R.j + 2*R.k + assert srepr(Laplacian(s3)) == \ + 'Laplacian(Add(Pow(R.x, Integer(2)), Pow(R.y, Integer(2)), Pow(R.z, Integer(2))))'		[ { "components": [ { "doc": "Represents unevaluated Laplacian.\n\nExamples\n========\n\n>>> from sympy.vector import CoordSys3D, Laplacian\n>>> R = CoordSys3D('R')\n>>> v = 3R.x3R.y*2R.z*3\n>>> Laplacian(v)\nLaplacian(3R.x*3R.y*2R.z**3)", "lines": [ 330, 353 ...	[ "test_sympy__vector__operators__Laplacian", "test_Gradient", "test_Divergence", "test_Curl" ]	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added class to represent unevaluated laplacian. <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> Fixes #13664 #### Brief description of what is fixed or changed `Laplacian` class added to represent unevaluated Laplacian in `vector/operators.py`. ``` >>> from sympy.vector import Laplacian, CoordSys3D >>> R = CoordSys3D('R') >>> v = R.x3 + R.y3 + R.z3 >>> Laplacian(v) Laplacian(R.x3 + R.y3 + R.z3) >>> Laplacian(v).doit() 6R.x + 6R.y + 6R.z ``` #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> vector * added Laplacian class to represent unevaluated laplacian. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/vector/operators.py] (definition of Laplacian:) class Laplacian(Expr): """Represents unevaluated Laplacian. Examples ======== >>> from sympy.vector import CoordSys3D, Laplacian >>> R = CoordSys3D('R') >>> v = 3R.x3R.y*2R.z*3 >>> Laplacian(v) Laplacian(3R.x*3R.y*2R.z3)""" (definition of Laplacian.__new__:) def __new__(cls, expr): (definition of Laplacian.doit:) def doit(self, kwargs): [end of new definitions in sympy/vector/operators.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Full support of laplacian in vector package In #12261 `laplacian` function was added. I think that it could be good idea to add to `vector` package full support of `laplacian` operator like it is done for `del` operator. For example support for `laplacian` may looks: ```python C = CoordSys3D('C') i, j, k = C.base_vectors() x, y, z = C.base_scalars() delop = Del() lap = Laplacian() v = xy2 v1 = delop(v)).doit() # C.y2C.i + 2C.xC.yC.j delop & v1 # 2C.x lap * v2 # 2C.x, not sure if this operator is the best here ``` Another advantage of adding `laplacian` is better looking of unevaluated latex form. Instead of printing `del` twice we have one `delta` symbol. @Upabjojr, @gxyd, what do you think? I'd like to work on this issue. ---------- `lap = Laplacian()` I don't really like the idea of overloading the `` operator in general (it makes everything so confused when parsing _Mul_ expressions). I think it's best to use the name _Laplacian_ for unevaluated expressions, and use the function call `( )` for the operator application. > use the function call ( ) for the operator application. I might agree with you, but shouldn't it introduce discrepancy between `laplacian` and `del` operators? I mean, for `del` we have operator itself (`Del()`) and acting operator (`gradient(...)`, `curl(...)`, etc.), but for `laplacian` only acting operator. What do you think? We already have a `Del()` operator, the Laplacian could be represented by adding `_eval_power` or something similar to `Del`. -------------------- </issues>	e941ad69638189ea42507331e417b88837357dec
sympy__sympy-16194	16,194	sympy/sympy	1.4	0e987498b00167fdd4a08a41c852a97cb70ce8f2	2019-03-07T18:13:37Z	diff --git a/sympy/logic/boolalg.py b/sympy/logic/boolalg.py index e5cc6f680ba4..d81832e84711 100644 --- a/sympy/logic/boolalg.py +++ b/sympy/logic/boolalg.py @@ -719,6 +719,9 @@ def _eval_as_set(self): from sympy.sets.sets import Intersection return Intersection([arg.as_set() for arg in self.args]) + def _eval_rewrite_as_Nor(self, args, *kwargs): + return Nor([Not(arg) for arg in self.args]) + class Or(LatticeOp, BooleanFunction): """ @@ -772,6 +775,9 @@ def _eval_as_set(self): from sympy.sets.sets import Union return Union([arg.as_set() for arg in self.args]) + def _eval_rewrite_as_Nand(self, args, *kwargs): + return Nand([Not(arg) for arg in self.args]) + def _eval_simplify(self, ratio, measure, rational, inverse): # standard simplify rv = super(Or, self)._eval_simplify( @@ -1004,6 +1010,16 @@ def to_nnf(self, simplify=True): args.append(Or(clause)) return And._to_nnf(args, simplify=simplify) + def _eval_rewrite_as_Or(self, args, kwargs): + a = self.args + return Or([_convert_to_varsSOP(x, self.args) + for x in _get_odd_parity_terms(len(a))]) + + def _eval_rewrite_as_And(self, args, kwargs): + a = self.args + return And([_convert_to_varsPOS(x, self.args) + for x in _get_even_parity_terms(len(a))]) + def _eval_simplify(self, ratio, measure, rational, inverse): # as standard simplify uses simplify_logic which writes things as # And and Or, we only simplify the partial expressions before using patterns @@ -1931,6 +1947,32 @@ def _convert_to_varsPOS(maxterm, variables): return Or(temp) +def _get_odd_parity_terms(n): + """ + Returns a list of lists, with all possible combinations of n zeros and ones + with an odd number of ones. + """ + op = [] + for i in range(1, 2n): + e = ibin(i, n) + if sum(e) % 2 == 1: + op.append(e) + return op + + +def _get_even_parity_terms(n): + """ + Returns a list of lists, with all possible combinations of n zeros and ones + with an even number of ones. + """ + op = [] + for i in range(2*n): + e = ibin(i, n) + if sum(e) % 2 == 0: + op.append(e) + return op + + def _simplified_pairs(terms): """ Reduces a set of minterms, if possible, to a simplified set of minterms @@ -2035,6 +2077,7 @@ def _input_to_binlist(inputlist, variables): raise TypeError("A term list can only contain lists, ints or dicts.") return binlist + def SOPform(variables, minterms, dontcares=None): """ The SOPform function uses simplified_pairs and a redundant group-	diff --git a/sympy/logic/tests/test_boolalg.py b/sympy/logic/tests/test_boolalg.py index 529a489221ed..e0f04a991ca2 100644 --- a/sympy/logic/tests/test_boolalg.py +++ b/sympy/logic/tests/test_boolalg.py @@ -109,6 +109,26 @@ def test_Xor(): assert Xor(e, e.canonical) == Xor(0, 0) == Xor(1, 1) +def test_rewrite_as_And(): + expr = x ^ y + assert expr.rewrite(And) == (x \| y) & (~x \| ~y) + + +def test_rewrite_as_Or(): + expr = x ^ y + assert expr.rewrite(Or) == (x & ~y) \| (y & ~x) + + +def test_rewrite_as_Nand(): + expr = (y & z) \| (z & ~w) + assert expr.rewrite(Nand) == ~(~(y & z) & ~(z & ~w)) + + +def test_rewrite_as_Nor(): + expr = z & (y \| ~w) + assert expr.rewrite(Nor) == ~(~z \| ~(y \| ~w)) + + def test_Not(): raises(TypeError, lambda: Not(True, False)) assert Not(True) is false		[ { "components": [ { "doc": "", "lines": [ 722, 723 ], "name": "And._eval_rewrite_as_Nor", "signature": "def _eval_rewrite_as_Nor(self, args, *kwargs):", "type": "function" }, { "doc": "", "lines": [ ...	[ "test_rewrite_as_And", "test_rewrite_as_Or", "test_rewrite_as_Nand", "test_rewrite_as_Nor" ]	[ "test_overloading", "test_And", "test_Or", "test_Xor", "test_Not", "test_Nand", "test_Nor", "test_Xnor", "test_Implies", "test_Equivalent", "test_equals", "test_simplification", "test_bool_map", "test_bool_symbol", "test_is_boolean", "test_subs", "test_commutative", "test_and_assoc...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> logic equation suggestions <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #16137 #### Brief description of what is fixed or changed ```expr._rewrite_as_And, expr._rewrite_as_Or, expr._rewrite_as_Nor, expr._rewrite_as_Nand``` added to logic equations. #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * logic * `And` can be rewritten as `Nor`, `Or` as `Nand`, and `Xor` as either `Or`or `And`. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/logic/boolalg.py] (definition of And._eval_rewrite_as_Nor:) def _eval_rewrite_as_Nor(self, args, kwargs): (definition of Or._eval_rewrite_as_Nand:) def _eval_rewrite_as_Nand(self, args, *kwargs): (definition of Xor._eval_rewrite_as_Or:) def _eval_rewrite_as_Or(self, args, *kwargs): (definition of Xor._eval_rewrite_as_And:) def _eval_rewrite_as_And(self, args, **kwargs): (definition of _get_odd_parity_terms:) def _get_odd_parity_terms(n): """Returns a list of lists, with all possible combinations of n zeros and ones with an odd number of ones.""" (definition of _get_even_parity_terms:) def _get_even_parity_terms(n): """Returns a list of lists, with all possible combinations of n zeros and ones with an even number of ones.""" [end of new definitions in sympy/logic/boolalg.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		e941ad69638189ea42507331e417b88837357dec
sympy__sympy-16189	16,189	sympy/sympy	1.4	0e987498b00167fdd4a08a41c852a97cb70ce8f2	2019-03-07T10:42:03Z	diff --git a/sympy/core/expr.py b/sympy/core/expr.py index 38bd1d2deffd..cd76f61a87ea 100644 --- a/sympy/core/expr.py +++ b/sympy/core/expr.py @@ -3537,6 +3537,27 @@ def _n2(a, b): return dif +def unchanged(func, args): + """Return True if `func` applied to the `args` is unchanged. + Can be used instead of `assert foo == foo`. + + Examples + ======== + + >>> from sympy.core.expr import unchanged + >>> from sympy.functions.elementary.trigonometric import cos + >>> from sympy.core.numbers import pi + + >>> unchanged(cos, 1) # instead of assert cos(1) == cos(1) + True + + >>> unchanged(cos, pi) + False + """ + f = func(args) + return f.func == func and f.args == tuple([sympify(a) for a in args]) + + from .mul import Mul from .add import Add from .power import Pow	diff --git a/sympy/functions/elementary/tests/test_complexes.py b/sympy/functions/elementary/tests/test_complexes.py index d328db8c8e8f..b0568209620b 100644 --- a/sympy/functions/elementary/tests/test_complexes.py +++ b/sympy/functions/elementary/tests/test_complexes.py @@ -5,6 +5,7 @@ Interval, comp, Integral, Matrix, ImmutableMatrix, SparseMatrix, ImmutableSparseMatrix, MatrixSymbol, FunctionMatrix, Lambda, Derivative) from sympy.utilities.pytest import XFAIL, raises +from sympy.core.expr import unchanged def N_equals(a, b): @@ -32,7 +33,7 @@ def test_re(): assert re(E) == E assert re(-E) == -E - assert re(x) == re(x) + assert unchanged(re, x) assert re(xI) == -im(x) assert re(rI) == 0 assert re(r) == r @@ -128,7 +129,7 @@ def test_im(): assert im(EI) == E assert im(-EI) == -E - assert im(x) == im(x) + assert unchanged(im, x) assert im(xI) == re(x) assert im(rI) == r assert im(r) == 0 diff --git a/sympy/polys/tests/test_rootoftools.py b/sympy/polys/tests/test_rootoftools.py index 494094743316..a402b4cd9d81 100644 --- a/sympy/polys/tests/test_rootoftools.py +++ b/sympy/polys/tests/test_rootoftools.py @@ -16,6 +16,7 @@ ) from sympy.utilities.pytest import raises, slow +from sympy.core.expr import unchanged from sympy.core.compatibility import range from sympy.abc import a, b, x, y, z, r @@ -138,11 +139,11 @@ def test_CRootOf___eval_Eq__(): r1 = rootof(eq, 1) assert Eq(r, r1) is S.false assert Eq(r, r) is S.true - assert Eq(r, x).lhs is r and Eq(r, x).rhs is x + assert unchanged(Eq, r, x) assert Eq(r, 0) is S.false assert Eq(r, S.Infinity) is S.false assert Eq(r, I) is S.false - assert Eq(r, f(0)).lhs is r and Eq(r, f(0)).rhs is f(0) + assert unchanged(Eq, r, f(0)) sol = solve(eq) for s in sol: if s.is_real: @@ -572,4 +573,4 @@ def test_eval_approx_relative(): def test_issue_15920(): r = rootof(x**5 - x + 1, 0) p = Integral(x, (x, 1, y)) - assert Eq(r, p).lhs is r and Eq(r, p).rhs is p + assert unchanged(Eq, r, p)		[ { "components": [ { "doc": "Return True if `func` applied to the `args` is unchanged.\nCan be used instead of `assert foo == foo`.\n\nExamples\n========\n\n>>> from sympy.core.expr import unchanged\n>>> from sympy.functions.elementary.trigonometric import cos\n>>> from sympy.core.numbers import pi...	[ "test_re", "test_im", "test_sign", "test_as_real_imag", "test_Abs", "test_Abs_rewrite", "test_Abs_real", "test_Abs_properties", "test_abs", "test_arg", "test_arg_rewrite", "test_adjoint", "test_conjugate", "test_conjugate_transpose", "test_transpose", "test_polarify", "test_unpolarif...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added an unchanged function in utilities Added a function `unchanged` in utilities/misc.py for checking if the expression remains unchanged. Return `True` if unchanged and `False` if changed <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> Fixes #16177 #### Brief description of what is fixed or changed Earlier in test cases, `assert foo == foo` was used in many places which really does nothing. After this change, using `assert unchanged(foo)` will give an error if the expression gets simplified. Eg. `unchanged(sin(x))` will come out to be True `unchanged(sin(pi))` will come out to be False as it simplifies to `0` #### Other comments I have added 2 test cases in `functions/tests/test_complexes.py` which used `assert re(x) == re(x)` and `assert im(x) == im(x)` Not sure if I should add more #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * utilities * Added a function `unchanged` which evaluates if expression is changed or not <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/core/expr.py] (definition of unchanged:) def unchanged(func, *args): """Return True if `func` applied to the `args` is unchanged. Can be used instead of `assert foo == foo`. Examples ======== >>> from sympy.core.expr import unchanged >>> from sympy.functions.elementary.trigonometric import cos >>> from sympy.core.numbers import pi >>> unchanged(cos, 1) # instead of assert cos(1) == cos(1) True >>> unchanged(cos, pi) False""" [end of new definitions in sympy/core/expr.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> add function to test for unchanged expression In #2942 there was a lot of discussion about tests that write `assert foo == foo`. An idea that I left there was this function which I still think could be used for cases when you want to assert that what you typed remained unchanged: ```python def unchanged(func, args): """Return True if `func` applied to the `args` is unchanged. Examples ======== >>> unchanged(cos, 1) # instead of assert cos(1) == cos(1) True """ f = func(args) return f.func == func and f.args == tuple([sympify(a) for a in args]) ``` ---------- I guess that could be used e.g. here [https://github.com/sympy/sympy/pull/15923#discussion_r262006408](https://github.com/sympy/sympy/pull/15923#discussion_r262006408) I'll take this @smichr @oscarbenjamin should we add this function to `utilities/pytest.py`? We are going to use this method just for testing. Right? Or are we planning to use this method for general purpose (other than testing) as well? It will be just for testing but probably doesn't want to go in pytest.py. The pytest.py file is supposed to be a compatibility layer that either imports functions from pytest or defines them if pytest isn't installed. Since this function isn't defined in pytest it should go somewhere else. I guess I'd put this in utilities/misc.py. -------------------- </issues>	e941ad69638189ea42507331e417b88837357dec
sympy__sympy-16142	16,142	sympy/sympy	1.4	8d8addc912dcef24e759ff8c62ff197cb7052931	2019-03-02T15:38:24Z	diff --git a/sympy/ntheory/__init__.py b/sympy/ntheory/__init__.py index 6d7ca7de9a2a..92c75d343860 100644 --- a/sympy/ntheory/__init__.py +++ b/sympy/ntheory/__init__.py @@ -9,7 +9,7 @@ pollard_pm1, pollard_rho, primefactors, totient, trailing, divisor_count, \ divisor_sigma, factorrat, reduced_totient, primenu, primeomega, \ mersenne_prime_exponent, is_perfect, is_mersenne_prime, is_abundant, \ - is_deficient, abundance + is_deficient, is_amicable, abundance from .partitions_ import npartitions from .residue_ntheory import is_primitive_root, is_quad_residue, \ legendre_symbol, jacobi_symbol, n_order, sqrt_mod, quadratic_residues, \ diff --git a/sympy/ntheory/factor_.py b/sympy/ntheory/factor_.py index 19f3d90985c4..7ffb6d95dbec 100644 --- a/sympy/ntheory/factor_.py +++ b/sympy/ntheory/factor_.py @@ -2201,3 +2201,30 @@ def is_deficient(n): if is_perfect(n): return False return bool(abundance(n) < 0) + + +def is_amicable(m, n): + """Returns True if the numbers `m` and `n` are "amicable", else False. + + Amicable numbers are two different numbers so related that the sum + of the proper divisors of each is equal to that of the other. + + Examples + ======== + + >>> from sympy.ntheory.factor_ import is_amicable, divisor_sigma + >>> is_amicable(220, 284) + True + >>> divisor_sigma(220) == divisor_sigma(284) + True + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Amicable_numbers + + """ + if m == n: + return False + a, b = map(lambda i: divisor_sigma(i), (m, n)) + return a == b == (m + n)	diff --git a/sympy/ntheory/tests/test_factor_.py b/sympy/ntheory/tests/test_factor_.py index 55e6d207cb89..4c48c4d8d5ab 100644 --- a/sympy/ntheory/tests/test_factor_.py +++ b/sympy/ntheory/tests/test_factor_.py @@ -14,7 +14,7 @@ from sympy.ntheory.factor_ import (smoothness, smoothness_p, antidivisors, antidivisor_count, core, digits, udivisors, udivisor_sigma, udivisor_count, primenu, primeomega, small_trailing, mersenne_prime_exponent, - is_perfect, is_mersenne_prime, is_abundant, is_deficient) + is_perfect, is_mersenne_prime, is_abundant, is_deficient, is_amicable) from sympy.ntheory.generate import cycle_length from sympy.ntheory.multinomial import ( multinomial_coefficients, multinomial_coefficients_iterator) @@ -606,3 +606,9 @@ def test_is_deficient(): assert is_deficient(56) is False assert is_deficient(20) is False assert is_deficient(36) is False + + +def test_is_amicable(): + assert is_amicable(173, 129) is False + assert is_amicable(220, 284) is True + assert is_amicable(8756, 8756) is False		[ { "components": [ { "doc": "Returns True if the numbers `m` and `n` are \"amicable\", else False.\n\nAmicable numbers are two different numbers so related that the sum\nof the proper divisors of each is equal to that of the other.\n\nExamples\n========\n\n>>> from sympy.ntheory.factor_ import is_a...	[ "test_trailing_bitcount", "test_multiplicity", "test_perfect_power", "test_factorint", "test_divisors_and_divisor_count", "test_udivisors_and_udivisor_count", "test_issue_6981", "test_totient", "test_reduced_totient", "test_divisor_sigma", "test_udivisor_sigma", "test_issue_4356", "test_divi...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added Functions for Amicable Number Amicable numbers are two different numbers so related that the sum of the proper divisors of each is equal to the other number. A proper divisor of a number is a positive factor of that number other than the number itself. For example, the proper divisors of 6 are 1, 2, and 3. <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### Brief description of what is fixed or changed Added Functions for Amicable Number with test cases #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - ntheory - Added Functions for Amicable Number <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/ntheory/factor_.py] (definition of is_amicable:) def is_amicable(m, n): """Returns True if the numbers `m` and `n` are "amicable", else False. Amicable numbers are two different numbers so related that the sum of the proper divisors of each is equal to that of the other. Examples ======== >>> from sympy.ntheory.factor_ import is_amicable, divisor_sigma >>> is_amicable(220, 284) True >>> divisor_sigma(220) == divisor_sigma(284) True References ========== .. [1] https://en.wikipedia.org/wiki/Amicable_numbers""" [end of new definitions in sympy/ntheory/factor_.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		e941ad69638189ea42507331e417b88837357dec
sympy__sympy-16136	16,136	sympy/sympy	1.4	b786c995a59a7bb0e673e80ccb4ccece4dfbcaad	2019-03-02T13:00:06Z	diff --git a/sympy/utilities/__init__.py b/sympy/utilities/__init__.py index 4a5f8d59608f..96bb668185b6 100644 --- a/sympy/utilities/__init__.py +++ b/sympy/utilities/__init__.py @@ -5,7 +5,8 @@ variations, numbered_symbols, cartes, capture, dict_merge, postorder_traversal, interactive_traversal, prefixes, postfixes, sift, topological_sort, unflatten, - has_dups, has_variety, reshape, default_sort_key, ordered) + has_dups, has_variety, reshape, default_sort_key, ordered, + rotations) from .misc import filldedent diff --git a/sympy/utilities/iterables.py b/sympy/utilities/iterables.py index 935bef529bc3..a03d97fa6124 100644 --- a/sympy/utilities/iterables.py +++ b/sympy/utilities/iterables.py @@ -2340,3 +2340,23 @@ def signed_permutations(t): """ return (type(t)(i) for j in permutations(t) for i in permute_signs(j)) + + +def rotations(s, dir=1): + """Return a generator giving the items in s as list where + each subsequent list has the items rotated to the left (default) + or right (dir=-1) relative to the previous list. + + Examples + ======== + + >>> from sympy.utilities.iterables import rotations + >>> list(rotations([1,2,3])) + [[1, 2, 3], [2, 3, 1], [3, 1, 2]] + >>> list(rotations([1,2,3], -1)) + [[1, 2, 3], [3, 1, 2], [2, 3, 1]] + """ + seq = list(s) + for i in range(len(seq)): + yield seq + seq = rotate_left(seq, dir)	diff --git a/sympy/utilities/tests/test_iterables.py b/sympy/utilities/tests/test_iterables.py index 9998af33e1b0..2fb1f5692f6a 100644 --- a/sympy/utilities/tests/test_iterables.py +++ b/sympy/utilities/tests/test_iterables.py @@ -15,7 +15,7 @@ multiset_permutations, necklaces, numbered_symbols, ordered, partitions, permutations, postfixes, postorder_traversal, prefixes, reshape, rotate_left, rotate_right, runs, sift, subsets, take, topological_sort, - unflatten, uniq, variations, ordered_partitions) + unflatten, uniq, variations, ordered_partitions, rotations) from sympy.utilities.enumerative import ( factoring_visitor, multiset_partitions_taocp ) @@ -732,3 +732,9 @@ def test_ordered_partitions(): sum(1 for p in f(i, j, 1)) == sum(1 for p in f(i, j, 0)) == nT(i, j)) + + +def test_rotations(): + assert list(rotations('ab')) == [['a', 'b'], ['b', 'a']] + assert list(rotations(range(3))) == [[0, 1, 2], [1, 2, 0], [2, 0, 1]] + assert list(rotations(range(3), dir=-1)) == [[0, 1, 2], [2, 0, 1], [1, 2, 0]]		[ { "components": [ { "doc": "Return a generator giving the items in s as list where\neach subsequent list has the items rotated to the left (default)\nor right (dir=-1) relative to the previous list.\n\nExamples\n========\n\n>>> from sympy.utilities.iterables import rotations\n>>> list(rotations([1...	[ "test_postorder_traversal", "test_flatten", "test_group", "test_subsets", "test_variations", "test_cartes", "test_filter_symbols", "test_numbered_symbols", "test_sift", "test_take", "test_dict_merge", "test_prefixes", "test_postfixes", "test_topological_sort", "test_rotate", "test_mult...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Function for rotation in iterables <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs Fixes #16127 <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed Function yielding sequence rotations has been added to iterables.py of the utilities module. #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * utilities * `rotations` function added to iterables.py <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/utilities/iterables.py] (definition of rotations:) def rotations(s, dir=1): """Return a generator giving the items in s as list where each subsequent list has the items rotated to the left (default) or right (dir=-1) relative to the previous list. Examples ======== >>> from sympy.utilities.iterables import rotations >>> list(rotations([1,2,3])) [[1, 2, 3], [2, 3, 1], [3, 1, 2]] >>> list(rotations([1,2,3], -1)) [[1, 2, 3], [3, 1, 2], [2, 3, 1]]""" [end of new definitions in sympy/utilities/iterables.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> iterables could use rotations Would a simple routine to return the rotations of a sequence be something useful in iterables? ```python def rotations(s, dir=1): """Return a generator giving the items in s as list where each subsequent list has the items rotated to the left (default) or right (dir=-1) relative to the previous list. Examples ======== >>> list(rotations([1,2,3])) [[1, 2, 3], [2, 3, 1], [3, 1, 2]] >>> list(rotations([1,2,3], -1)) [[1, 2, 3], [3, 1, 2], [2, 3, 1]] """ seq = list(s) for i in range(len(seq)): yield seq seq = rotate_left(seq, dir) ``` ---------- -------------------- </issues>	e941ad69638189ea42507331e417b88837357dec
sympy__sympy-16109	16,109	sympy/sympy	1.4	a302bbeb5fa4418be4ad82b6b5b3607de3f2d65d	2019-02-28T20:05:57Z	diff --git a/sympy/ntheory/__init__.py b/sympy/ntheory/__init__.py index bf0065221703..6d7ca7de9a2a 100644 --- a/sympy/ntheory/__init__.py +++ b/sympy/ntheory/__init__.py @@ -8,7 +8,8 @@ from .factor_ import divisors, factorint, multiplicity, perfect_power, \ pollard_pm1, pollard_rho, primefactors, totient, trailing, divisor_count, \ divisor_sigma, factorrat, reduced_totient, primenu, primeomega, \ - mersenne_prime_exponent, is_perfect, is_mersenne_prime + mersenne_prime_exponent, is_perfect, is_mersenne_prime, is_abundant, \ + is_deficient, abundance from .partitions_ import npartitions from .residue_ntheory import is_primitive_root, is_quad_residue, \ legendre_symbol, jacobi_symbol, n_order, sqrt_mod, quadratic_residues, \ diff --git a/sympy/ntheory/factor_.py b/sympy/ntheory/factor_.py index ac3c62983615..19f3d90985c4 100644 --- a/sympy/ntheory/factor_.py +++ b/sympy/ntheory/factor_.py @@ -2129,3 +2129,75 @@ def is_mersenne_prime(n): r, b = integer_log(n + 1, 2) return b and r in MERSENNE_PRIME_EXPONENTS + + +def abundance(n): + """Returns the difference between the sum of the positive + proper divisors of a number and the number. + + Examples + ======== + + >>> from sympy.ntheory import abundance, is_perfect, is_abundant + >>> abundance(6) + 0 + >>> is_perfect(6) + True + >>> abundance(10) + -2 + >>> is_abundant(10) + False + """ + return divisor_sigma(n, 1) - 2 * n + + +def is_abundant(n): + """Returns True if ``n`` is an abundant number, else False. + + A abundant number is smaller than the sum of its positive proper divisors. + + Examples + ======== + + >>> from sympy.ntheory.factor_ import is_abundant + >>> is_abundant(20) + True + >>> is_abundant(15) + False + + References + ========== + + .. [1] http://mathworld.wolfram.com/AbundantNumber.html + + """ + n = as_int(n) + if is_perfect(n): + return False + return n % 6 == 0 or bool(abundance(n) > 0) + + +def is_deficient(n): + """Returns True if ``n`` is a deficient number, else False. + + A deficient number is greater than the sum of its positive proper divisors. + + Examples + ======== + + >>> from sympy.ntheory.factor_ import is_deficient + >>> is_deficient(20) + False + >>> is_deficient(15) + True + + References + ========== + + .. [1] http://mathworld.wolfram.com/DeficientNumber.html + + """ + n = as_int(n) + if is_perfect(n): + return False + return bool(abundance(n) < 0)	diff --git a/sympy/ntheory/tests/test_factor_.py b/sympy/ntheory/tests/test_factor_.py index 6226323e26ac..55e6d207cb89 100644 --- a/sympy/ntheory/tests/test_factor_.py +++ b/sympy/ntheory/tests/test_factor_.py @@ -13,7 +13,8 @@ factorrat, reduced_totient) from sympy.ntheory.factor_ import (smoothness, smoothness_p, antidivisors, antidivisor_count, core, digits, udivisors, udivisor_sigma, - udivisor_count, primenu, primeomega, small_trailing, mersenne_prime_exponent, is_perfect, is_mersenne_prime) + udivisor_count, primenu, primeomega, small_trailing, mersenne_prime_exponent, + is_perfect, is_mersenne_prime, is_abundant, is_deficient) from sympy.ntheory.generate import cycle_length from sympy.ntheory.multinomial import ( multinomial_coefficients, multinomial_coefficients_iterator) @@ -589,3 +590,19 @@ def test_is_mersenne_prime(): assert is_mersenne_prime(511) is False assert is_mersenne_prime(131071) is True assert is_mersenne_prime(2147483647) is True + + +def test_is_abundant(): + assert is_abundant(10) is False + assert is_abundant(12) is True + assert is_abundant(18) is True + assert is_abundant(21) is False + assert is_abundant(945) is True + + +def test_is_deficient(): + assert is_deficient(10) is True + assert is_deficient(22) is True + assert is_deficient(56) is False + assert is_deficient(20) is False + assert is_deficient(36) is False		[ { "components": [ { "doc": "Returns the difference between the sum of the positive\nproper divisors of a number and the number.\n\nExamples\n========\n\n>>> from sympy.ntheory import abundance, is_perfect, is_abundant\n>>> abundance(6)\n0\n>>> is_perfect(6)\nTrue\n>>> abundance(10)\n-2\n>>> is_abu...	[ "test_trailing_bitcount", "test_multiplicity", "test_perfect_power", "test_factorint", "test_divisors_and_divisor_count", "test_udivisors_and_udivisor_count", "test_issue_6981", "test_totient", "test_reduced_totient", "test_divisor_sigma", "test_udivisor_sigma", "test_issue_4356", "test_divi...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added is_abundant and is_deficient with test cases <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> Fixes #15926 closes #16112 as an alternative Function for perfect number has already been merged on PR #16101 #### Brief description of what is fixed or changed Added functions for abundant and deficient numbers and a function to compute the abundance of a number. #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - ntheory - actor_: added funtions `abundance`, `is_abundant` and `is_deficient` <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/ntheory/factor_.py] (definition of abundance:) def abundance(n): """Returns the difference between the sum of the positive proper divisors of a number and the number. Examples ======== >>> from sympy.ntheory import abundance, is_perfect, is_abundant >>> abundance(6) 0 >>> is_perfect(6) True >>> abundance(10) -2 >>> is_abundant(10) False""" (definition of is_abundant:) def is_abundant(n): """Returns True if ``n`` is an abundant number, else False. A abundant number is smaller than the sum of its positive proper divisors. Examples ======== >>> from sympy.ntheory.factor_ import is_abundant >>> is_abundant(20) True >>> is_abundant(15) False References ========== .. [1] http://mathworld.wolfram.com/AbundantNumber.html""" (definition of is_deficient:) def is_deficient(n): """Returns True if ``n`` is a deficient number, else False. A deficient number is greater than the sum of its positive proper divisors. Examples ======== >>> from sympy.ntheory.factor_ import is_deficient >>> is_deficient(20) False >>> is_deficient(15) True References ========== .. [1] http://mathworld.wolfram.com/DeficientNumber.html""" [end of new definitions in sympy/ntheory/factor_.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Function for perfect, deficient, abundant numbers There should be a separate function for checking whether a number is perfect, deficient or abundant. If you liked this idea then I can add a pull request. - [x] perfect - [x] deficient - [x] abundant ---------- I think it would be good to have. For perfect numbers, there are only [51 known ones](https://en.wikipedia.org/wiki/Mersenne_prime), so we could just check against a list. I don't know if there is an efficient way to test if a number is abundant. I think ntheory/factor_.py would be the appropriate place @asmeurer I can think of the following heuristics for this. 1. All primes and its powers are deficient. 2. Every multiple of abundant and perfect number is abundant. This will need some changes. Please suggest. I have checked outputs. It takes some time to calculate 40th Perfect Numbers to 51th Perfect Numbers. but We can show it with symbol. I also have test cases for Perfect Numbers. I can add them if you want to. I have not added comments yet. Comments can also be added. I'm working on deficient and will try to cover abundant as well. --------------------Function addition for deficient numbers <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs Fixes #15926 <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed A function is implemented for `deficient numbers `in `number theory`. #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * ntheory * Addition of function deficient in factor_.py <!-- END RELEASE NOTES --> ---------- -------------------- </issues>	e941ad69638189ea42507331e417b88837357dec
scikit-learn__scikit-learn-13336	13,336	scikit-learn/scikit-learn	0.21	984871b89baa183b1d0e284ac9bb22de06a59e8d	2019-02-28T15:54:52Z	diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 6f504a721ec75..e3e3ec9f88816 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -230,6 +230,10 @@ Support for Python 3.4 and below has been officially dropped. in version 0.21 and will be removed in version 0.23. :issue:`12821` by :user:`Nicolas Hug <NicolasHug>`. +- \|Enhancement\| `sparse_cg` solver in :class:`linear_model.ridge.Ridge` + now supports fitting the intercept (i.e. ``fit_intercept=True``) when + inputs are sparse . :issue:`13336` by :user:`Bartosz Telenczuk <btel>` + :mod:`sklearn.manifold` ............................ diff --git a/sklearn/linear_model/ridge.py b/sklearn/linear_model/ridge.py index eed636622dcdc..e240db3f1cb06 100644 --- a/sklearn/linear_model/ridge.py +++ b/sklearn/linear_model/ridge.py @@ -33,9 +33,31 @@ from ..exceptions import ConvergenceWarning -def _solve_sparse_cg(X, y, alpha, max_iter=None, tol=1e-3, verbose=0): +def _solve_sparse_cg(X, y, alpha, max_iter=None, tol=1e-3, verbose=0, + X_offset=None, X_scale=None): + + def _get_rescaled_operator(X): + + X_offset_scale = X_offset / X_scale + + def matvec(b): + return X.dot(b) - b.dot(X_offset_scale) + + def rmatvec(b): + return X.T.dot(b) - X_offset_scale * np.sum(b) + + X1 = sparse.linalg.LinearOperator(shape=X.shape, + matvec=matvec, + rmatvec=rmatvec) + return X1 + n_samples, n_features = X.shape - X1 = sp_linalg.aslinearoperator(X) + + if X_offset is None or X_scale is None: + X1 = sp_linalg.aslinearoperator(X) + else: + X1 = _get_rescaled_operator(X) + coefs = np.empty((y.shape[1], n_features), dtype=X.dtype) if n_features > n_samples: @@ -326,6 +348,25 @@ def ridge_regression(X, y, alpha, sample_weight=None, solver='auto', ----- This function won't compute the intercept. """ + + return _ridge_regression(X, y, alpha, + sample_weight=sample_weight, + solver=solver, + max_iter=max_iter, + tol=tol, + verbose=verbose, + random_state=random_state, + return_n_iter=return_n_iter, + return_intercept=return_intercept, + X_scale=None, + X_offset=None) + + +def _ridge_regression(X, y, alpha, sample_weight=None, solver='auto', + max_iter=None, tol=1e-3, verbose=0, random_state=None, + return_n_iter=False, return_intercept=False, + X_scale=None, X_offset=None): + if return_intercept and sparse.issparse(X) and solver != 'sag': if solver != 'auto': warnings.warn("In Ridge, only 'sag' solver can currently fit the " @@ -395,7 +436,12 @@ def ridge_regression(X, y, alpha, sample_weight=None, solver='auto', n_iter = None if solver == 'sparse_cg': - coef = _solve_sparse_cg(X, y, alpha, max_iter, tol, verbose) + coef = _solve_sparse_cg(X, y, alpha, + max_iter=max_iter, + tol=tol, + verbose=verbose, + X_offset=X_offset, + X_scale=X_scale) elif solver == 'lsqr': coef, n_iter = _solve_lsqr(X, y, alpha, max_iter, tol) @@ -492,24 +538,35 @@ def fit(self, X, y, sample_weight=None): np.atleast_1d(sample_weight).ndim > 1): raise ValueError("Sample weights must be 1D array or scalar") + # when X is sparse we only remove offset from y X, y, X_offset, y_offset, X_scale = self._preprocess_data( X, y, self.fit_intercept, self.normalize, self.copy_X, - sample_weight=sample_weight) + sample_weight=sample_weight, return_mean=True) # temporary fix for fitting the intercept with sparse data using 'sag' - if sparse.issparse(X) and self.fit_intercept: - self.coef_, self.n_iter_, self.intercept_ = ridge_regression( + if (sparse.issparse(X) and self.fit_intercept and + self.solver != 'sparse_cg'): + self.coef_, self.n_iter_, self.intercept_ = _ridge_regression( X, y, alpha=self.alpha, sample_weight=sample_weight, max_iter=self.max_iter, tol=self.tol, solver=self.solver, random_state=self.random_state, return_n_iter=True, return_intercept=True) + # add the offset which was subtracted by _preprocess_data self.intercept_ += y_offset else: - self.coef_, self.n_iter_ = ridge_regression( + if sparse.issparse(X): + # required to fit intercept with sparse_cg solver + params = {'X_offset': X_offset, 'X_scale': X_scale} + else: + # for dense matrices or when intercept is set to 0 + params = {} + + self.coef_, self.n_iter_ = _ridge_regression( X, y, alpha=self.alpha, sample_weight=sample_weight, max_iter=self.max_iter, tol=self.tol, solver=self.solver, random_state=self.random_state, return_n_iter=True, - return_intercept=False) + return_intercept=False, **params) + self._set_intercept(X_offset, y_offset, X_scale) return self	diff --git a/sklearn/linear_model/tests/test_ridge.py b/sklearn/linear_model/tests/test_ridge.py index eca4a53f4f507..a5ee524e8c557 100644 --- a/sklearn/linear_model/tests/test_ridge.py +++ b/sklearn/linear_model/tests/test_ridge.py @@ -815,21 +815,25 @@ def test_n_iter(): def test_ridge_fit_intercept_sparse(): X, y = make_regression(n_samples=1000, n_features=2, n_informative=2, bias=10., random_state=42) + X_csr = sp.csr_matrix(X) - for solver in ['saga', 'sag']: + for solver in ['sag', 'sparse_cg']: dense = Ridge(alpha=1., tol=1.e-15, solver=solver, fit_intercept=True) sparse = Ridge(alpha=1., tol=1.e-15, solver=solver, fit_intercept=True) dense.fit(X, y) - sparse.fit(X_csr, y) + with pytest.warns(None) as record: + sparse.fit(X_csr, y) + assert len(record) == 0 assert_almost_equal(dense.intercept_, sparse.intercept_) assert_array_almost_equal(dense.coef_, sparse.coef_) # test the solver switch and the corresponding warning - sparse = Ridge(alpha=1., tol=1.e-15, solver='lsqr', fit_intercept=True) - assert_warns(UserWarning, sparse.fit, X_csr, y) - assert_almost_equal(dense.intercept_, sparse.intercept_) - assert_array_almost_equal(dense.coef_, sparse.coef_) + for solver in ['saga', 'lsqr']: + sparse = Ridge(alpha=1., tol=1.e-15, solver=solver, fit_intercept=True) + assert_warns(UserWarning, sparse.fit, X_csr, y) + assert_almost_equal(dense.intercept_, sparse.intercept_) + assert_array_almost_equal(dense.coef_, sparse.coef_) def test_errors_and_values_helper():	diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 6f504a721ec75..e3e3ec9f88816 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -230,6 +230,10 @@ Support for Python 3.4 and below has been officially dropped. in version 0.21 and will be removed in version 0.23. :issue:`12821` by :user:`Nicolas Hug <NicolasHug>`. +- \|Enhancement\| `sparse_cg` solver in :class:`linear_model.ridge.Ridge` + now supports fitting the intercept (i.e. ``fit_intercept=True``) when + inputs are sparse . :issue:`13336` by :user:`Bartosz Telenczuk <btel>` + :mod:`sklearn.manifold` ............................	[ { "components": [ { "doc": "", "lines": [ 39, 52 ], "name": "_solve_sparse_cg._get_rescaled_operator", "signature": "def _get_rescaled_operator(X):", "type": "function" }, { "doc": "", "lines": [ 43, ...	[ "sklearn/linear_model/tests/test_ridge.py::test_ridge_fit_intercept_sparse" ]	[ "sklearn/linear_model/tests/test_ridge.py::test_ridge[svd]", "sklearn/linear_model/tests/test_ridge.py::test_ridge[sparse_cg]", "sklearn/linear_model/tests/test_ridge.py::test_ridge[cholesky]", "sklearn/linear_model/tests/test_ridge.py::test_ridge[lsqr]", "sklearn/linear_model/tests/test_ridge.py::test_ridg...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG] Implement fitting intercept with `sparse_cg` solver in Ridge regression <!-- Thanks for contributing a pull request! Please ensure you have taken a look at the contribution guidelines: https://github.com/scikit-learn/scikit-learn/blob/master/CONTRIBUTING.md#pull-request-checklist --> #### Reference Issues/PRs <!-- Example: Fixes #1234. See also #3456. Please use keywords (e.g., Fixes) to create link to the issues or pull requests you resolved, so that they will automatically be closed when your pull request is merged. See https://github.com/blog/1506-closing-issues-via-pull-requests --> See also #470 It follows the same trick as introduced in PR #13279 by @agramfort #### What does this implement/fix? Explain your changes. This implements fitting intercept with `sparse_cg` solver in Ridge regression (i.e. when `fit_intercept==True`) for sparse inputs. It also means that both sparse and dense cases give the same result. #### Any other comments? Important: This PR changes the auto-selected solver (`solver='auto'`) from `sag` to `sparse_cg` when `fit_intercept==True` and input is sparse. There are still problems with the code: 1) 'auto' mode in ridge_regression function may trigger wrong solvers (for example, when inputs is sparse and sample_weight is passed) 2) Warning message about changing the solver is not fully informative/correct. For example, user might choose the `sparse_cg` solver instead of going the `sag` way. 3) The estimator object is not informed about the fact that the solver was changed (or which solver was selected by `auto`) They are not related to this PR and will be fixed in another PR. <!-- Please be aware that we are a loose team of volunteers so patience is necessary; assistance handling other issues is very welcome. We value all user contributions, no matter how minor they are. If we are slow to review, either the pull request needs some benchmarking, tinkering, convincing, etc. or more likely the reviewers are simply busy. In either case, we ask for your understanding during the review process. For more information, see our FAQ on this topic: http://scikit-learn.org/dev/faq.html#why-is-my-pull-request-not-getting-any-attention. Thanks for contributing! --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/linear_model/ridge.py] (definition of _solve_sparse_cg._get_rescaled_operator:) def _get_rescaled_operator(X): (definition of _solve_sparse_cg._get_rescaled_operator.matvec:) def matvec(b): (definition of _solve_sparse_cg._get_rescaled_operator.rmatvec:) def rmatvec(b): (definition of _ridge_regression:) def _ridge_regression(X, y, alpha, sample_weight=None, solver='auto', max_iter=None, tol=1e-3, verbose=0, random_state=None, return_n_iter=False, return_intercept=False, X_scale=None, X_offset=None): [end of new definitions in sklearn/linear_model/ridge.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		66cc1c7342f7f0cc0dc57fb6d56053fc46c8e5f0
sympy__sympy-16101	16,101	sympy/sympy	1.4	f4b483507a6704f2f431494413c54766f3d77d3e	2019-02-27T23:44:13Z	diff --git a/sympy/ntheory/__init__.py b/sympy/ntheory/__init__.py index 31977979af8f..bf0065221703 100644 --- a/sympy/ntheory/__init__.py +++ b/sympy/ntheory/__init__.py @@ -7,7 +7,8 @@ from .primetest import isprime from .factor_ import divisors, factorint, multiplicity, perfect_power, \ pollard_pm1, pollard_rho, primefactors, totient, trailing, divisor_count, \ - divisor_sigma, factorrat, reduced_totient, primenu, primeomega + divisor_sigma, factorrat, reduced_totient, primenu, primeomega, \ + mersenne_prime_exponent, is_perfect, is_mersenne_prime from .partitions_ import npartitions from .residue_ntheory import is_primitive_root, is_quad_residue, \ legendre_symbol, jacobi_symbol, n_order, sqrt_mod, quadratic_residues, \ diff --git a/sympy/ntheory/factor_.py b/sympy/ntheory/factor_.py index 2d3362822a7c..ac3c62983615 100644 --- a/sympy/ntheory/factor_.py +++ b/sympy/ntheory/factor_.py @@ -19,6 +19,14 @@ from .primetest import isprime from .generate import sieve, primerange, nextprime + +# Note: This list should be updated whenever new Mersenne primes are found. +# Refer: https://www.mersenne.org/ +MERSENNE_PRIME_EXPONENTS = (2, 3, 5, 7, 13, 17, 19, 31, 61, 89, 107, 127, 521, 607, 1279, 2203, + 2281, 3217, 4253, 4423, 9689, 9941, 11213, 19937, 21701, 23209, 44497, 86243, 110503, 132049, + 216091, 756839, 859433, 1257787, 1398269, 2976221, 3021377, 6972593, 13466917, 20996011, 24036583, + 25964951, 30402457, 32582657, 37156667, 42643801, 43112609, 57885161, 74207281, 77232917, 82589933) + small_trailing = [0] * 256 for j in range(1,8): small_trailing[1<<j::1<<(j+1)] = [j] * (1<<(7-j)) @@ -2040,3 +2048,84 @@ def eval(cls, n): raise ValueError("n must be a positive integer") else: return sum(factorint(n).values()) + + +def mersenne_prime_exponent(nth): + """Returns the exponent ``i`` for the nth Mersenne prime (which + has the form `2^i - 1`). + + Examples + ======== + + >>> from sympy.ntheory.factor_ import mersenne_prime_exponent + >>> mersenne_prime_exponent(1) + 2 + >>> mersenne_prime_exponent(20) + 4423 + """ + n = as_int(nth) + if n < 1: + raise ValueError("nth must be a positive integer; mersenne_prime_exponent(1) == 2") + if n > 51: + raise ValueError("There are only 51 perfect numbers; nth must be less than or equal to 51") + return MERSENNE_PRIME_EXPONENTS[n - 1] + + +def is_perfect(n): + """Returns True if ``n`` is a perfect number, else False. + + A perfect number is equal to the sum of its positive, proper divisors. + + Examples + ======== + + >>> from sympy.ntheory.factor_ import is_perfect, divisors + >>> is_perfect(20) + False + >>> is_perfect(6) + True + >>> sum(divisors(6)[:-1]) + 6 + + References + ========== + + .. [1] http://mathworld.wolfram.com/PerfectNumber.html + + """ + from sympy.core.power import integer_log + + r, b = integer_nthroot(1 + 8*n, 2) + if not b: + return False + n, x = divmod(1 + r, 4) + if x: + return False + e, b = integer_log(n, 2) + return b and (e + 1) in MERSENNE_PRIME_EXPONENTS + + +def is_mersenne_prime(n): + """Returns True if ``n`` is a Mersenne prime, else False. + + A Mersenne prime is a prime number having the form `2^i - 1`. + + Examples + ======== + + >>> from sympy.ntheory.factor_ import is_mersenne_prime + >>> is_mersenne_prime(6) + False + >>> is_mersenne_prime(127) + True + + References + ========== + + .. [1] http://mathworld.wolfram.com/MersennePrime.html + + """ + from sympy.core.power import integer_log + + r, b = integer_log(n + 1, 2) + return b and r in MERSENNE_PRIME_EXPONENTS	diff --git a/sympy/ntheory/tests/test_factor_.py b/sympy/ntheory/tests/test_factor_.py index 2bcb8b5e62d9..6226323e26ac 100644 --- a/sympy/ntheory/tests/test_factor_.py +++ b/sympy/ntheory/tests/test_factor_.py @@ -13,7 +13,7 @@ factorrat, reduced_totient) from sympy.ntheory.factor_ import (smoothness, smoothness_p, antidivisors, antidivisor_count, core, digits, udivisors, udivisor_sigma, - udivisor_count, primenu, primeomega, small_trailing) + udivisor_count, primenu, primeomega, small_trailing, mersenne_prime_exponent, is_perfect, is_mersenne_prime) from sympy.ntheory.generate import cycle_length from sympy.ntheory.multinomial import ( multinomial_coefficients, multinomial_coefficients_iterator) @@ -562,3 +562,30 @@ def test_primeomega(): assert primeomega(n) assert primeomega(n).subs(n, 2 ** 31 - 1) == 1 assert summation(primeomega(n), (n, 2, 30)) == 59 + + +def test_mersenne_prime_exponent(): + assert mersenne_prime_exponent(1) == 2 + assert mersenne_prime_exponent(4) == 7 + assert mersenne_prime_exponent(10) == 89 + assert mersenne_prime_exponent(25) == 21701 + raises(ValueError, lambda: mersenne_prime_exponent(52)) + raises(ValueError, lambda: mersenne_prime_exponent(0)) + + +def test_is_perfect(): + assert is_perfect(6) is True + assert is_perfect(15) is False + assert is_perfect(28) is True + assert is_perfect(400) is False + assert is_perfect(496) is True + assert is_perfect(8128) is True + assert is_perfect(10000) is False + + +def test_is_mersenne_prime(): + assert is_mersenne_prime(10) is False + assert is_mersenne_prime(127) is True + assert is_mersenne_prime(511) is False + assert is_mersenne_prime(131071) is True + assert is_mersenne_prime(2147483647) is True		[ { "components": [ { "doc": "Returns the exponent ``i`` for the nth Mersenne prime (which\nhas the form `2^i - 1`).\n\nExamples\n========\n\n>>> from sympy.ntheory.factor_ import mersenne_prime_exponent\n>>> mersenne_prime_exponent(1)\n2\n>>> mersenne_prime_exponent(20)\n4423", "lines": [ ...	[ "test_trailing_bitcount", "test_multiplicity", "test_perfect_power", "test_factorint", "test_divisors_and_divisor_count", "test_udivisors_and_udivisor_count", "test_issue_6981", "test_totient", "test_reduced_totient", "test_divisor_sigma", "test_udivisor_sigma", "test_issue_4356", "test_divi...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Functions for Perfect Number <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> part of #15926 #### Brief description of what is fixed or changed Added mersenne_prime_exponent ,is_perfect and is_mersenne_prime #### Other comments Already been reviewed at #16055 #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> - ntheory - added ischeck functions for both perfect number and mersenne prime using list of mersenne prime exponents. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/ntheory/factor_.py] (definition of mersenne_prime_exponent:) def mersenne_prime_exponent(nth): """Returns the exponent ``i`` for the nth Mersenne prime (which has the form `2^i - 1`). Examples ======== >>> from sympy.ntheory.factor_ import mersenne_prime_exponent >>> mersenne_prime_exponent(1) 2 >>> mersenne_prime_exponent(20) 4423""" (definition of is_perfect:) def is_perfect(n): """Returns True if ``n`` is a perfect number, else False. A perfect number is equal to the sum of its positive, proper divisors. Examples ======== >>> from sympy.ntheory.factor_ import is_perfect, divisors >>> is_perfect(20) False >>> is_perfect(6) True >>> sum(divisors(6)[:-1]) 6 References ========== .. [1] http://mathworld.wolfram.com/PerfectNumber.html""" (definition of is_mersenne_prime:) def is_mersenne_prime(n): """Returns True if ``n`` is a Mersenne prime, else False. A Mersenne prime is a prime number having the form `2^i - 1`. Examples ======== >>> from sympy.ntheory.factor_ import is_mersenne_prime >>> is_mersenne_prime(6) False >>> is_mersenne_prime(127) True References ========== .. [1] http://mathworld.wolfram.com/MersennePrime.html""" [end of new definitions in sympy/ntheory/factor_.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		e941ad69638189ea42507331e417b88837357dec
falconry__falcon-1459	1,459	falconry/falcon	null	4fd9de5c8a3f8a71f59b375bb374082312e673e8	2019-02-24T01:46:19Z	diff --git a/falcon/request.py b/falcon/request.py index 669bdd7cc..4ddcf54b8 100644 --- a/falcon/request.py +++ b/falcon/request.py @@ -355,32 +355,24 @@ class Request(object): range_unit (str): Unit of the range parsed from the value of the Range header, or ``None`` if the header is missing if_match (list): Value of the If-Match header, as a parsed list of - :class:`falcon.ETag` objects or ``None`` if the header is missing. + :class:`falcon.ETag` objects or ``None`` if the header is missing + or its value is blank. - This property is determined by the value of ``HTTP_IF_MATCH`` - in the WSGI environment dict. + This property provides a list of all ``entity-tags`` in the + header, both strong and weak, in the same order as listed in + the header. - Note: - This property includes strong and weak entity-tags. Per - `RFC 7239`_, two entity-tags are equivalent if both are not - weak and their opaque-tags match character-by-character. - - (See also: RFC 7239, Section 3.1) + (See also: RFC 7232, Section 3.1) if_none_match (list): Value of the If-None-Match header, as a parsed list of :class:`falcon.ETag` objects or ``None`` if the header is - missing. + missing or its value is blank. - This property is determined by the value of ``HTTP_IF_NONE_MATCH`` - in the WSGI environment dict. - - Note: - This property includes strong and weak entity-tags. Per - `RFC 7239`_, two entity-tags are equivalent if their - opaque-tags match character-by-character, regardless of - either or both being tagged as weak. + This property provides a list of all ``entity-tags`` in the + header, both strong and weak, in the same order as listed in + the header. - (See also: RFC 7239, Section 3.2) + (See also: RFC 7232, Section 3.2) if_modified_since (datetime): Value of the If-Modified-Since header, or ``None`` if the header is missing. @@ -433,6 +425,8 @@ class Request(object): _cookies = None _cookies_collapsed = None + _cached_if_match = None + _cached_if_none_match = None # Child classes may override this context_type = type('RequestContext', (dict,), {}) @@ -619,11 +613,30 @@ def date(self): @property def if_match(self): - return helpers.parse_etags(self.env.get('HTTP_IF_MATCH')) + # TODO(kgriffs): It may make sense at some point to create a + # header property generator that DRY's up the memoization + # pattern for us. + # PERF(kgriffs): It probably isn't worth it to set + # self._cached_if_match to a special type/object to distinguish + # between the variable being unset and the header not being + # present in the request. The reason is that if the app + # gets a None back on the first reference to property, it + # probably isn't going to access the property again (TBD). + if self._cached_if_match is None: + header_value = self.env.get('HTTP_IF_MATCH') + if header_value: + self._cached_if_match = helpers._parse_etags(header_value) + + return self._cached_if_match @property def if_none_match(self): - return helpers.parse_etags(self.env.get('HTTP_IF_NONE_MATCH')) + if self._cached_if_none_match is None: + header_value = self.env.get('HTTP_IF_NONE_MATCH') + if header_value: + self._cached_if_none_match = helpers._parse_etags(header_value) + + return self._cached_if_none_match @property def if_modified_since(self): diff --git a/falcon/request_helpers.py b/falcon/request_helpers.py index db7ca02ef..276939041 100644 --- a/falcon/request_helpers.py +++ b/falcon/request_helpers.py @@ -28,7 +28,12 @@ # _COOKIE_NAME_RESERVED_CHARS = re.compile('[\x00-\x1F\x7F-\xFF()<>@,;:\\\\"/[\\]?={} \x09]') -_ETAG_PATTERN = re.compile(r'([Ww]/)?(?:"(.?)"\|(.?))(?:\s,\s\|$)') +# NOTE(kgriffs): strictly speaking, the weakness indicator is +# case-sensitive, but this wasn't explicit until RFC 7232 +# so we allow for both. We also require quotes because that's +# been standardized since 1999, and it makes the regex simpler +# and more performant. +_ENTITY_TAG_PATTERN = re.compile(r'([Ww]/)?"([^"])"') def parse_cookie_header(header_value): @@ -113,26 +118,18 @@ def fget(self): return property(fget) -def make_etag(value, is_weak=False): - """Creates and returns a ETag object. +# NOTE(kgriffs): Going forward we should privatize helpers, as done here. We +# can always move this over to falcon.util if we decide it would be +# more generally useful to app developers. +def _parse_etags(etag_str): + """Parse a string containing one or more HTTP entity-tags. - Args: - value (str): Unquated entity tag value - is_weak (bool): The weakness indicator - - Returns: - A ``str``-like Etag instance with weakness indicator. + The string is assumed to be formatted as defined for a precondition + header, and may contain either a single ETag, or multiple comma-separated + ETags. The string may also contain a '' character, in order to indicate + that any ETag should match the precondition. - """ - etag = ETag(value) - etag.is_weak = is_weak - return etag - - -def parse_etags(etag_str): - """ - Parse a string of ETags given in the If-Match or If-None-Match header as - defined by RFC 7232. + (See also: RFC 7232, Section 3) Args: etag_str (str): An ASCII header value to parse ETags from. ETag values @@ -140,42 +137,38 @@ def parse_etags(etag_str): function should be used. Returns: - A list of unquoted ETags or ``['']`` if all ETags should be matched. + list: A list of unquoted ETags or ``['']`` if all ETags should be + matched. If the string to be parse is empty, or contains only + whitespace, ``None`` will be returned instead. """ - if etag_str is None: - return None - etags = [] etag_str = etag_str.strip() if not etag_str: - return etags + return None if etag_str == '': - etags.append(etag_str) - return etags + return [etag_str] if ',' not in etag_str: - value = etag_str - is_weak = False - if value.startswith(('W/', 'w/')): - is_weak = True - value = value[2:] - if value[:1] == value[-1:] == '"': - value = value[1:-1] - etags.append(make_etag(value, is_weak)) - else: - pos = 0 - end = len(etag_str) - while pos < end: - match = _ETAG_PATTERN.match(etag_str, pos) - is_weak, quoted, raw = match.groups() - value = quoted or raw - if value: - etags.append(make_etag(value, bool(is_weak))) - pos = match.end() - - return etags + return [ETag.loads(etag_str)] + + etags = [] + + # PERF(kgriffs): Parsing out the weak string like this turns out to be more + # performant than grabbing the entire entity-tag and passing it to + # ETag.loads(). This is also faster than parsing etag_str manually via + # str.find() and slicing. + for weak, value in _ENTITY_TAG_PATTERN.findall(etag_str): + t = ETag(value) + t.is_weak = bool(weak) + etags.append(t) + + # NOTE(kgriffs): Normalize a string with only whitespace and commas + # to None, since it is like a list of individual ETag headers that + # are all set to nothing, and so therefore basically should be + # treated as not having been set in the first place. + return etags or None class BoundedStream(io.IOBase): diff --git a/falcon/util/structures.py b/falcon/util/structures.py index 26d6e7bce..cba3e77a0 100644 --- a/falcon/util/structures.py +++ b/falcon/util/structures.py @@ -108,22 +108,114 @@ def __repr__(self): class ETag(str): - """An entity-tag ``str``-like object with the weakness indicator. + """Convenience class to represent a parsed HTTP entity-tag. + + This class is simply a subclass of ``str`` with a few helper methods and + an extra attribute to indicate whether the entity-tag is weak or strong. The + value of the string is equivalent to what RFC 7232 calls an "opaque-tag", + i.e. an entity-tag sans quotes and the weakness indicator. + + Note: + + Given that a weak entity-tag comparison can be performed by + using the ``==`` operator (per the example below), only a + :meth:`~.strong_compare` method is provided. + + Here is an example ``on_get()`` method that demonstrates how to use instances + of this class:: + + def on_get(self, req, resp): + content_etag = self._get_content_etag() + for etag in (req.if_none_match or []): + if etag == '' or etag == content_etag: + resp.status = falcon.HTTP_304 + return + + # ... + + resp.etag = content_etag + resp.status = falcon.HTTP_200 + + (See also: RFC 7232) Attributes: - is_weak (bool): The weakness indicator. + is_weak (bool): ``True`` if the entity-tag is weak, otherwise ``False``. """ + is_weak = False - def to_header(self): - """Convert the ETag into a HTTP header string. + def strong_compare(self, other): + """Performs a strong entity-tag comparison. + + Two entity-tags are equivalent if both are not weak and their + opaque-tags match character-by-character. + + (See also: RFC 7232, Section 2.3.2) + + Arguments: + other (ETag): The other :class:`~.ETag` to which you are comparing + this one. + + Returns: + bool: ``True`` if the two entity-tags match, otherwise ``False``. + + """ + + return self == other and not (self.is_weak or other.is_weak) + + def dumps(self): + """Serialize the ETag to a string suitable for use in a precondition header. + + (See also: RFC 7232, Section 2.3) Returns: str: An opaque quoted string, possibly prefixed by a weakness indicator ``W/``. - """ + if self.is_weak: - return 'W/"%s"' % self - return '"%s"' % self + # PERF(kgriffs): Simple concatenation like this is slightly faster + # than %s string formatting. + return 'W/"' + self + '"' + + return '"' + self + '"' + + @classmethod + def loads(cls, etag_str): + """Class method that deserializes a single entity-tag string from a precondition header. + + Note: + + This method is meant to be used only for parsing a single + entity-tag. It can not be used to parse a comma-separated list of + values. + + (See also: RFC 7232, Section 2.3) + + Arguments: + etag_str (str): An ASCII string representing a single entity-tag, + as defined by RFC 7232. + + Returns: + ETag: An instance of `~.ETag` representing the parsed entity-tag. + + """ + + value = etag_str + + is_weak = False + if value.startswith(('W/', 'w/')): + is_weak = True + value = value[2:] + + # NOTE(kgriffs): We allow for an unquoted entity-tag just in case, + # although it has been non-standard to do so since at least 1999 + # with the advent of RFC 2616. + if value[:1] == value[-1:] == '"': + value = value[1:-1] + + t = cls(value) + t.is_weak = is_weak + + return t	diff --git a/tests/test_request_attrs.py b/tests/test_request_attrs.py index 2e710ff7d..a7f7b639b 100644 --- a/tests/test_request_attrs.py +++ b/tests/test_request_attrs.py @@ -5,14 +5,32 @@ import falcon from falcon.request import Request, RequestOptions -from falcon.request_helpers import make_etag +from falcon.request_helpers import _parse_etags import falcon.testing as testing import falcon.uri from falcon.util import compat +from falcon.util.structures import ETag _PROTOCOLS = ['HTTP/1.0', 'HTTP/1.1'] +def _make_etag(value, is_weak=False): + """Creates and returns an ETag object. + + Args: + value (str): Unquated entity tag value + is_weak (bool): The weakness indicator + + Returns: + A ``str``-like Etag instance with weakness indicator. + + """ + etag = ETag(value) + + etag.is_weak = is_weak + return etag + + class TestRequestAttributes(object): def setup_method(self, method): @@ -785,39 +803,121 @@ def test_app_missing(self): assert req.app == '' @pytest.mark.parametrize('etag,expected', [ - ('', []), - (',', []), + ('', None), + (' ', None), + (' ', None), + ('\t', None), + (' \t', None), + (',', None), + (',,', None), + (',, ', None), + (', , ', None), ('', ['']), ( 'W/"67ab43"', - [make_etag('67ab43', is_weak=True)] + [_make_etag('67ab43', is_weak=True)] ), ( 'w/"67ab43"', - [make_etag('67ab43', is_weak=True)] + [_make_etag('67ab43', is_weak=True)] + ), + ( + ' w/"67ab43"', + [_make_etag('67ab43', is_weak=True)] + ), + ( + 'w/"67ab43" ', + [_make_etag('67ab43', is_weak=True)] + ), + ( + 'w/"67ab43 " ', + [_make_etag('67ab43 ', is_weak=True)] ), ( '"67ab43"', - [make_etag('67ab43', is_weak=True)] + [_make_etag('67ab43')] + ), + ( + ' "67ab43"', + [_make_etag('67ab43')] + ), + ( + ' "67ab43" ', + [_make_etag('67ab43')] + ), + ( + '"67ab43" ', + [_make_etag('67ab43')] + ), + ( + '" 67ab43" ', + [_make_etag(' 67ab43')] + ), + ( + '67ab43"', + [_make_etag('67ab43"')] + ), + ( + '"67ab43', + [_make_etag('"67ab43')] ), ( '67ab43', - [make_etag('67ab43', is_weak=False)] + [_make_etag('67ab43')] + ), + ( + '67ab43 ', + [_make_etag('67ab43')] + ), + ( + ' 67ab43 ', + [_make_etag('67ab43')] + ), + ( + ' 67ab43', + [_make_etag('67ab43')] ), ( - 'W/"67ab43", "54ed21", 42we85', - [make_etag('67ab43', is_weak=True), - make_etag('54ed21', is_weak=False), - make_etag('42we85', is_weak=False)] + # NOTE(kgriffs): To simplify parsing and improve performance, we + # do not attempt to handle unquoted entity-tags when there is + # a list; it is non-standard anyway, and has been since 1999. + 'W/"67ab43", "54ed21", junk"F9,22", junk "41, 7F", unquoted, w/"22, 41, 7F", "", W/""', + [ + _make_etag('67ab43', is_weak=True), + _make_etag('54ed21'), + + # NOTE(kgriffs): Test that the ETag initializer defaults to + # is_weak == False + ETag('F9,22'), + + _make_etag('41, 7F'), + _make_etag('22, 41, 7F', is_weak=True), + + # NOTE(kgriffs): According to the grammar in RFC 7232, zero + # etagc's is acceptable. + _make_etag(''), + _make_etag('', is_weak=True), + ] ), ]) def test_etag(self, etag, expected): - self._test_header_expected_value('If-Match', etag, 'if_match', expected) - self._test_header_expected_value('If-None-Match', etag, 'if_none_match', expected) + self._test_header_etag('If-Match', etag, 'if_match', expected) + self._test_header_etag('If-None-Match', etag, 'if_none_match', expected) def test_etag_is_missing(self): - assert self.req.if_match is None - assert self.req.if_none_match is None + # NOTE(kgriffs): Loop in order to test caching + for __ in range(3): + assert self.req.if_match is None + assert self.req.if_none_match is None + + @pytest.mark.parametrize('header_value', ['', ' ', ' ']) + def test_etag_parsing_helper(self, header_value): + # NOTE(kgriffs): Test a couple of cases that are not directly covered + # elsewhere (but that we want the helper to still support + # for the sake of avoiding suprises if they are ever called without + # preflighting the header value). + + assert _parse_etags(header_value) is None # ------------------------------------------------------------------------- # Helpers @@ -836,6 +936,25 @@ def _test_header_expected_value(self, name, value, attr, expected_value): req = Request(testing.create_environ(headers=headers)) assert getattr(req, attr) == expected_value + def _test_header_etag(self, name, value, attr, expected_value): + headers = {name: value} + req = Request(testing.create_environ(headers=headers)) + + # NOTE(kgriffs): Loop in order to test caching + for __ in range(3): + value = getattr(req, attr) + + if expected_value is None: + assert value is None + return + + assert value is not None + + for element, expected_element in zip(value, expected_value): + assert element == expected_element + if isinstance(expected_element, ETag): + assert element.is_weak == expected_element.is_weak + def _test_error_details(self, headers, attr_name, error_type, title, description): req = Request(testing.create_environ(headers=headers)) diff --git a/tests/test_utils.py b/tests/test_utils.py index 4890e35cf..2626a2cd6 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -332,11 +332,47 @@ def test_get_http_status(self): falcon.get_http_status('-404.3') assert falcon.get_http_status(123, 'Go Away') == '123 Go Away' - def test_etag_to_header(self): + def test_etag_dumps_to_header_format(self): etag = structures.ETag('67ab43') - assert etag.to_header() == '"67ab43"' + + assert etag.dumps() == '"67ab43"' + etag.is_weak = True - assert etag.to_header() == 'W/"67ab43"' + assert etag.dumps() == 'W/"67ab43"' + + assert structures.ETag('67a b43').dumps() == '"67a b43"' + + def test_etag_strong_vs_weak_comparison(self): + strong_67ab43_one = structures.ETag.loads('"67ab43"') + strong_67ab43_too = structures.ETag.loads('"67ab43"') + strong_67aB43 = structures.ETag.loads('"67aB43"') + weak_67ab43_one = structures.ETag.loads('W/"67ab43"') + weak_67ab43_two = structures.ETag.loads('W/"67ab43"') + weak_67aB43 = structures.ETag.loads('W/"67aB43"') + + assert strong_67aB43 == strong_67aB43 + assert weak_67aB43 == weak_67aB43 + assert strong_67aB43 == weak_67aB43 + assert weak_67aB43 == strong_67aB43 + assert strong_67ab43_one == strong_67ab43_too + assert weak_67ab43_one == weak_67ab43_two + + assert strong_67aB43 != strong_67ab43_one + assert strong_67ab43_one != strong_67aB43 + + assert strong_67aB43.strong_compare(strong_67aB43) + assert strong_67ab43_one.strong_compare(strong_67ab43_too) + assert not strong_67aB43.strong_compare(strong_67ab43_one) + assert not strong_67ab43_one.strong_compare(strong_67aB43) + + assert not strong_67ab43_one.strong_compare(weak_67ab43_one) + assert not weak_67ab43_one.strong_compare(strong_67ab43_one) + + assert not weak_67aB43.strong_compare(weak_67aB43) + assert not weak_67ab43_one.strong_compare(weak_67ab43_two) + + assert not weak_67ab43_one.strong_compare(weak_67aB43) + assert not weak_67aB43.strong_compare(weak_67ab43_one) @pytest.mark.parametrize(		[ { "components": [ { "doc": "Parse a string containing one or more HTTP entity-tags.\n\nThe string is assumed to be formatted as defined for a precondition\nheader, and may contain either a single ETag, or multiple comma-separated\nETags. The string may also contain a '*' character, in order to ind...	[ "tests/test_request_attrs.py::TestRequestAttributes::test_missing_qs", "tests/test_request_attrs.py::TestRequestAttributes::test_empty", "tests/test_request_attrs.py::TestRequestAttributes::test_host", "tests/test_request_attrs.py::TestRequestAttributes::test_subdomain", "tests/test_request_attrs.py::TestRe...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat(etag): Improve etag performance and docs, plus usability of the ETag class ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in falcon/request_helpers.py] (definition of _parse_etags:) def _parse_etags(etag_str): """Parse a string containing one or more HTTP entity-tags. The string is assumed to be formatted as defined for a precondition header, and may contain either a single ETag, or multiple comma-separated ETags. The string may also contain a '' character, in order to indicate that any ETag should match the precondition. (See also: RFC 7232, Section 3) Args: etag_str (str): An ASCII header value to parse ETags from. ETag values within may be prefixed by ``W/`` to indicate that the weak comparison function should be used. Returns: list: A list of unquoted ETags or ``['']`` if all ETags should be matched. If the string to be parse is empty, or contains only whitespace, ``None`` will be returned instead.""" [end of new definitions in falcon/request_helpers.py] [start of new definitions in falcon/util/structures.py] (definition of ETag.strong_compare:) def strong_compare(self, other): """Performs a strong entity-tag comparison. Two entity-tags are equivalent if both are not weak and their opaque-tags match character-by-character. (See also: RFC 7232, Section 2.3.2) Arguments: other (ETag): The other :class:`~.ETag` to which you are comparing this one. Returns: bool: ``True`` if the two entity-tags match, otherwise ``False``.""" (definition of ETag.dumps:) def dumps(self): """Serialize the ETag to a string suitable for use in a precondition header. (See also: RFC 7232, Section 2.3) Returns: str: An opaque quoted string, possibly prefixed by a weakness indicator ``W/``.""" (definition of ETag.loads:) def loads(cls, etag_str): """Class method that deserializes a single entity-tag string from a precondition header. Note: This method is meant to be used only for parsing a single entity-tag. It can not be used to parse a comma-separated list of values. (See also: RFC 7232, Section 2.3) Arguments: etag_str (str): An ASCII string representing a single entity-tag, as defined by RFC 7232. Returns: ETag: An instance of `~.ETag` representing the parsed entity-tag.""" [end of new definitions in falcon/util/structures.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		77d5e6394a88ead151c9469494749f95f06b24bf
sympy__sympy-16057	16,057	sympy/sympy	1.4	5d06d9fcb8a954fc3ce0a0d8a69f1fc331b82880	2019-02-23T21:16:17Z	diff --git a/sympy/physics/optics/__init__.py b/sympy/physics/optics/__init__.py index 77306ae3e775..fc815db56c78 100644 --- a/sympy/physics/optics/__init__.py +++ b/sympy/physics/optics/__init__.py @@ -30,6 +30,7 @@ from . import utils -from .utils import (refraction_angle, deviation, brewster_angle, lens_makers_formula, +from .utils import (refraction_angle, fresnel_coefficients, + deviation, brewster_angle, critical_angle, lens_makers_formula, mirror_formula, lens_formula, hyperfocal_distance, transverse_magnification) __all__.extend(utils.__all__) diff --git a/sympy/physics/optics/medium.py b/sympy/physics/optics/medium.py index 83c7afdce7bc..9fc033e92586 100644 --- a/sympy/physics/optics/medium.py +++ b/sympy/physics/optics/medium.py @@ -120,9 +120,15 @@ def speed(self): >>> m = Medium('m') >>> m.speed 299792458meter/second + >>> m2 = Medium('m2', n=1) + >>> m.speed == m2.speed + True """ - return 1/sqrt(self._permittivityself._permeability) + if self._permittivity is not None and self._permeability is not None: + return 1/sqrt(self._permittivityself._permeability) + else: + return c/self._n @property def refractive_index(self): @@ -174,7 +180,8 @@ def permeability(self): def __str__(self): from sympy.printing import sstr - return type(self).__name__ + sstr(self.args) + return type(self).__name__ + ': ' + sstr([self._permittivity, + self._permeability, self._n]) def __lt__(self, other): """ diff --git a/sympy/physics/optics/utils.py b/sympy/physics/optics/utils.py index 015a47960fcc..599719d438fa 100644 --- a/sympy/physics/optics/utils.py +++ b/sympy/physics/optics/utils.py @@ -2,8 +2,10 @@ Contains* * refraction_angle +* fresnel_coefficients * deviation * brewster_angle +* critical_angle * lens_makers_formula * mirror_formula * lens_formula @@ -15,7 +17,9 @@ __all__ = ['refraction_angle', 'deviation', + 'fresnel_coefficients', 'brewster_angle', + 'critical_angle', 'lens_makers_formula', 'mirror_formula', 'lens_formula', @@ -23,9 +27,10 @@ 'transverse_magnification' ] -from sympy import Symbol, sympify, sqrt, Matrix, acos, oo, Limit, atan2 +from sympy import Symbol, sympify, sqrt, Matrix, acos, oo, Limit, atan2, asin,\ +cos, sin, tan, I, cancel from sympy.core.compatibility import is_sequence -from sympy.geometry.line import Ray3D +from sympy.geometry.line import Ray3D, Point3D from sympy.geometry.util import intersection from sympy.geometry.plane import Plane from .medium import Medium @@ -171,6 +176,94 @@ def refraction_angle(incident, medium1, medium2, normal=None, plane=None): return Ray3D(intersection_pt, direction_ratio=drs) +def fresnel_coefficients(angle_of_incidence, medium1, medium2): + """ + This function uses Fresnel equations to calculate reflection and + transmission coefficients. Those are obtained for both polarisations + when the electric field vector is in the plane of incidence (labelled 'p') + and when the electric field vector is perpendicular to the plane of + incidence (labelled 's'). There are four real coefficients unless the + incident ray reflects in total internal in which case there are two complex + ones. Angle of incidence is the angle between the incident ray and the + surface normal. ``medium1`` and ``medium2`` can be ``Medium`` or any + sympifiable object. + + Parameters + ========== + + angle_of_incidence : sympifiable + + medium1 : Medium or sympifiable + Medium 1 or its refractive index + + medium2 : Medium or sympifiable + Medium 2 or its refractive index + + Returns a list with four real Fresnel coefficients: + [reflection p (TM), reflection s (TE), + transmission p (TM), transmission s (TE)] + If the ray is undergoes total internal reflection then returns a + list of two complex Fresnel coefficients: + [reflection p (TM), reflection s (TE)] + + Examples + ======== + + >>> from sympy.physics.optics import fresnel_coefficients + >>> fresnel_coefficients(0.3, 1, 2) + [0.317843553417859, -0.348645229818821, + 0.658921776708929, 0.651354770181179] + >>> fresnel_coefficients(0.6, 2, 1) + [-0.235625382192159 - 0.971843958291041I, + 0.816477005968898 - 0.577377951366403I] + + References + ========== + + https://en.wikipedia.org/wiki/Fresnel_equations + """ + + if isinstance(medium1, Medium): + n1 = medium1.refractive_index + else: + n1 = sympify(medium1) + + if isinstance(medium2, Medium): + n2 = medium2.refractive_index + else: + n2 = sympify(medium2) + + angle_of_refraction = asin(n1sin(angle_of_incidence)/n2) + try: + angle_of_total_internal_reflection_onset = critical_angle(n1, n2) + except ValueError: + angle_of_total_internal_reflection_onset = None + + if angle_of_total_internal_reflection_onset == None or\ + angle_of_total_internal_reflection_onset > angle_of_incidence: + R_s = -sin(angle_of_incidence - angle_of_refraction)\ + /sin(angle_of_incidence + angle_of_refraction) + R_p = tan(angle_of_incidence - angle_of_refraction)\ + /tan(angle_of_incidence + angle_of_refraction) + T_s = 2sin(angle_of_refraction)cos(angle_of_incidence)\ + /sin(angle_of_incidence + angle_of_refraction) + T_p = 2sin(angle_of_refraction)cos(angle_of_incidence)\ + /(sin(angle_of_incidence + angle_of_refraction)\ + cos(angle_of_incidence - angle_of_refraction)) + return [R_p, R_s, T_p, T_s] + else: + n = n2/n1 + R_s = cancel((cos(angle_of_incidence)-\ + Isqrt(sin(angle_of_incidence)2 - n2))\ + /(cos(angle_of_incidence)+\ + Isqrt(sin(angle_of_incidence)2 - n2))) + R_p = cancel((n*2cos(angle_of_incidence)-\ + Isqrt(sin(angle_of_incidence)2 - n2))\ + /(n2cos(angle_of_incidence)+\ + Isqrt(sin(angle_of_incidence)2 - n*2))) + return [R_p, R_s] + + def deviation(incident, medium1, medium2, normal=None, plane=None): """ This function calculates the angle of deviation of a ray @@ -287,6 +380,45 @@ def brewster_angle(medium1, medium2): return atan2(n2, n1) +def critical_angle(medium1, medium2): + """ + This function calculates the critical angle of incidence (marking the onset + of total internal) to Medium 2 from Medium 1 in radians. + + Parameters + ========== + + medium 1 : Medium or sympifiable + Refractive index of Medium 1 + medium 2 : Medium or sympifiable + Refractive index of Medium 1 + + Examples + ======== + + >>> from sympy.physics.optics import critical_angle + >>> critical_angle(1.33, 1) + 0.850908514477849 + + """ + n1, n2 = None, None + + if isinstance(medium1, Medium): + n1 = medium1.refractive_index + else: + n1 = sympify(medium1) + + if isinstance(medium2, Medium): + n2 = medium2.refractive_index + else: + n2 = sympify(medium2) + + if n2 > n1: + raise ValueError('Total internal reflection impossible for n1 < n2') + else: + return asin(n2/n1) + + def lens_makers_formula(n_lens, n_surr, r1, r2): """	diff --git a/sympy/physics/optics/tests/test_utils.py b/sympy/physics/optics/tests/test_utils.py index 0155302e7e7c..22afadfcb04c 100644 --- a/sympy/physics/optics/tests/test_utils.py +++ b/sympy/physics/optics/tests/test_utils.py @@ -1,6 +1,7 @@ -from sympy.physics.optics.utils import (refraction_angle, deviation, - brewster_angle, lens_makers_formula, mirror_formula, lens_formula, - hyperfocal_distance, transverse_magnification) +from sympy.physics.optics.utils import (refraction_angle, fresnel_coefficients, + deviation, brewster_angle, critical_angle, lens_makers_formula, + mirror_formula, lens_formula, hyperfocal_distance, + transverse_magnification) from sympy.physics.optics.medium import Medium from sympy.physics.units import e0 @@ -62,10 +63,22 @@ def test_refraction_angle(): Ray3D(Point3D(0, 0, 0), direction_ratio=[1, 1, -1]) +def test_fresnel_coefficients(): + assert list(round(i, 5) for i in fresnel_coefficients(0.5, 1, 1.33)) == \ + [0.11163, -0.17138, 0.83581, 0.82862] + assert list(round(i, 5) for i in fresnel_coefficients(0.5, 1.33, 1)) == \ + [-0.07726, 0.20482, 1.22724, 1.20482] + m1 = Medium('m1') + m2 = Medium('m2', n=2) + assert list(round(i, 5) for i in fresnel_coefficients(0.3, m1, m2)) == \ + [0.31784, -0.34865, 0.65892, 0.65135] + assert list(list(round(j, 5) for j in i.as_real_imag()) for i in \ + fresnel_coefficients(0.6, m2, m1)) == \ + [[-0.23563, -0.97184], [0.81648, -0.57738]] + + def test_deviation(): n1, n2 = symbols('n1, n2') - m1 = Medium('m1') - m2 = Medium('m2') r1 = Ray3D(Point3D(-1, -1, 1), Point3D(0, 0, 0)) n = Matrix([0, 0, 1]) i = Matrix([-1, -1, -1]) @@ -81,11 +94,20 @@ def test_deviation(): def test_brewster_angle(): + m1 = Medium('m1', n=1) + m2 = Medium('m2', n=1.33) + assert round(brewster_angle(m1, m2), 2) == 0.93 m1 = Medium('m1', permittivity=e0, n=1) m2 = Medium('m2', permittivity=e0, n=1.33) assert round(brewster_angle(m1, m2), 2) == 0.93 +def test_critical_angle(): + m1 = Medium('m1', n=1) + m2 = Medium('m2', n=1.33) + assert round(critical_angle(m2, m1), 2) == 0.85 + + def test_lens_makers_formula(): n1, n2 = symbols('n1, n2') m1 = Medium('m1', permittivity=e0, n=1)		[ { "components": [ { "doc": "This function uses Fresnel equations to calculate reflection and\ntransmission coefficients. Those are obtained for both polarisations\nwhen the electric field vector is in the plane of incidence (labelled 'p')\nand when the electric field vector is perpendicular to the...	[ "test_refraction_angle", "test_fresnel_coefficients", "test_deviation", "test_brewster_angle", "test_critical_angle", "test_lens_makers_formula", "test_mirror_formula", "test_lens_formula", "test_hyperfocal_distance" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Calculation of critical angle and Fresnel coefficients <!-- BEGIN RELEASE NOTES --> * physics.optics * Added two new functions to `physics.optics.utils`: 1) `critical_angle() `calculates the onset of total internal reflection, "TIR" when possible (n2 < n1) 2) `fresnel_coefficients()` calculates real reflection and transmission coefficients when out of TIR and complex ones when the ray is TIR'ed <!-- END RELEASE NOTES --> * Small fix: calculating speed of light in medium is possible given only the refractive index. * Associated tests * The motivation for the above being that SymPy is well-suited to become a basic 'optics calculator' which would be a go-to tool for small tasks especially given that it can be used via SymPy Live. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/physics/optics/utils.py] (definition of fresnel_coefficients:) def fresnel_coefficients(angle_of_incidence, medium1, medium2): """This function uses Fresnel equations to calculate reflection and transmission coefficients. Those are obtained for both polarisations when the electric field vector is in the plane of incidence (labelled 'p') and when the electric field vector is perpendicular to the plane of incidence (labelled 's'). There are four real coefficients unless the incident ray reflects in total internal in which case there are two complex ones. Angle of incidence is the angle between the incident ray and the surface normal. ``medium1`` and ``medium2`` can be ``Medium`` or any sympifiable object. Parameters ========== angle_of_incidence : sympifiable medium1 : Medium or sympifiable Medium 1 or its refractive index medium2 : Medium or sympifiable Medium 2 or its refractive index Returns a list with four real Fresnel coefficients: [reflection p (TM), reflection s (TE), transmission p (TM), transmission s (TE)] If the ray is undergoes total internal reflection then returns a list of two complex Fresnel coefficients: [reflection p (TM), reflection s (TE)] Examples ======== >>> from sympy.physics.optics import fresnel_coefficients >>> fresnel_coefficients(0.3, 1, 2) [0.317843553417859, -0.348645229818821, 0.658921776708929, 0.651354770181179] >>> fresnel_coefficients(0.6, 2, 1) [-0.235625382192159 - 0.971843958291041I, 0.816477005968898 - 0.577377951366403I] References ========== https://en.wikipedia.org/wiki/Fresnel_equations""" (definition of critical_angle:) def critical_angle(medium1, medium2): """This function calculates the critical angle of incidence (marking the onset of total internal) to Medium 2 from Medium 1 in radians. Parameters ========== medium 1 : Medium or sympifiable Refractive index of Medium 1 medium 2 : Medium or sympifiable Refractive index of Medium 1 Examples ======== >>> from sympy.physics.optics import critical_angle >>> critical_angle(1.33, 1) 0.850908514477849""" [end of new definitions in sympy/physics/optics/utils.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		e941ad69638189ea42507331e417b88837357dec
pyocd__pyOCD-540	540	pyocd/pyOCD	null	31c3ca684cb7b595662d1fd378a9272e1e6ac8fe	2019-02-16T22:43:45Z	diff --git a/pyocd/board/board.py b/pyocd/board/board.py index 9e3eea1c2..7efee6015 100644 --- a/pyocd/board/board.py +++ b/pyocd/board/board.py @@ -17,16 +17,19 @@ from ..target import TARGET from ..target.pack import pack_target +from ..utility.graph import GraphNode import logging import six log = logging.getLogger('board') -class Board(object): +class Board(GraphNode): """ This class associates a target and flash to create a board. """ def __init__(self, session, target=None): + super(Board, self).__init__() + # As a last resort, default the target to 'cortex_m'. if target is None: target = 'cortex_m' @@ -47,6 +50,8 @@ def __init__(self, session, target=None): log.error("target '%s' not recognized", self._target_type) six.raise_from(KeyError("target '%s' not recognized" % self._target_type), exc) self._inited = False + + self.add_child(self.target) ## @brief Initialize the board. def init(self): diff --git a/pyocd/core/coresight_target.py b/pyocd/core/coresight_target.py index fc1c297d4..6409d0d96 100644 --- a/pyocd/core/coresight_target.py +++ b/pyocd/core/coresight_target.py @@ -24,6 +24,7 @@ from ..debug.cache import CachingDebugContext from ..debug.elf.elf import ELFBinaryFile from ..debug.elf.flash_reader import FlashReaderContext +from ..utility.graph import GraphNode from ..utility.notification import Notification from ..utility.sequencer import CallSequence from ..target.pack.flash_algo import PackFlashAlgo @@ -46,10 +47,11 @@ # the CortexM object for the core. Multicore devices work differently. This class tracks # a "selected core", to which all actions are directed. The selected core can be changed # at any time. You may also directly access specific cores and perform operations on them. -class CoreSightTarget(Target): +class CoreSightTarget(Target, GraphNode): def __init__(self, session, memoryMap=None): - super(CoreSightTarget, self).__init__(session, memoryMap) + Target.__init__(self, session, memoryMap) + GraphNode.__init__(self) self.root_target = self self.part_number = self.__class__.__name__ self.cores = {} @@ -114,6 +116,7 @@ def add_core(self, core): core.delegate = self.delegate core.set_target_context(CachingDebugContext(DebugContext(core))) self.cores[core.core_number] = core + self.add_child(core) self._root_contexts[core.core_number] = None def create_init_sequence(self): @@ -189,6 +192,7 @@ def create_flash(self): region.flash = obj def _create_component(self, cmpid): + logging.debug("Creating %s component", cmpid.name) cmp = cmpid.factory(cmpid.ap, cmpid, cmpid.address) cmp.init() diff --git a/pyocd/coresight/component.py b/pyocd/coresight/component.py index bc9bca254..def825a68 100644 --- a/pyocd/coresight/component.py +++ b/pyocd/coresight/component.py @@ -1,5 +1,5 @@ # pyOCD debugger -# Copyright (c) 2018 Arm Limited +# Copyright (c) 2018-2019 Arm Limited # SPDX-License-Identifier: Apache-2.0 # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -14,17 +14,15 @@ # See the License for the specific language governing permissions and # limitations under the License. -import logging +from ..utility.graph import GraphNode -log = logging.getLogger("component") +class CoreSightComponent(GraphNode): + """! @brief CoreSight component base class.""" -## @brief CoreSight component base class. -# -# x -class CoreSightComponent(object): - ## @brief Constructor. - # def __init__(self, ap, cmpid=None, addr=None): + """! @brief Constructor.""" + super(CoreSightComponent, self).__init__() + """! @brief Constructor.""" self._ap = ap self._cmpid = cmpid self._address = addr or (cmpid.address if cmpid else None) diff --git a/pyocd/coresight/cortex_m.py b/pyocd/coresight/cortex_m.py index d1d894d73..0324ff727 100644 --- a/pyocd/coresight/cortex_m.py +++ b/pyocd/coresight/cortex_m.py @@ -430,7 +430,9 @@ def __init__(self, rootTarget, ap, memoryMap=None, core_num=0, cmpid=None, addre self.bp_manager.add_provider(self.sw_bp, Target.BREAKPOINT_SW) ## @brief Connect related CoreSight components. - def connect(self, cmp): + def add_child(self, cmp): + super(CortexM, self).add_child(cmp) + if isinstance(cmp, FPB): self.fpb = cmp self.bp_manager.add_provider(cmp, Target.BREAKPOINT_HW) diff --git a/pyocd/coresight/dwt.py b/pyocd/coresight/dwt.py index 88710e093..aa704fd2c 100644 --- a/pyocd/coresight/dwt.py +++ b/pyocd/coresight/dwt.py @@ -58,7 +58,7 @@ class DWT(CoreSightComponent): def factory(cls, ap, cmpid, address): dwt = cls(ap, cmpid, address) assert ap.core - ap.core.connect(dwt) + ap.core.add_child(dwt) return dwt def __init__(self, ap, cmpid=None, addr=None): diff --git a/pyocd/coresight/fpb.py b/pyocd/coresight/fpb.py index b93486540..ceb6d38d0 100644 --- a/pyocd/coresight/fpb.py +++ b/pyocd/coresight/fpb.py @@ -37,7 +37,7 @@ class FPB(BreakpointProvider, CoreSightComponent): def factory(cls, ap, cmpid, address): fpb = cls(ap, cmpid, address) assert ap.core - ap.core.connect(fpb) + ap.core.add_child(fpb) return fpb def __init__(self, ap, cmpid=None, addr=None): diff --git a/pyocd/coresight/rom_table.py b/pyocd/coresight/rom_table.py index 1f083b07a..4f4a2f1bd 100644 --- a/pyocd/coresight/rom_table.py +++ b/pyocd/coresight/rom_table.py @@ -262,7 +262,8 @@ def __init__(self, ap, cmpid=None, addr=None, parent_table=None): if addr is None: addr = ap.rom_addr super(ROMTable, self).__init__(ap, cmpid, addr) - self.parent = parent_table + if parent_table is not None: + parent_table.add_child(self) self.number = (self.parent.number + 1) if self.parent else 0 self.components = [] self.name = 'ROM' diff --git a/pyocd/utility/graph.py b/pyocd/utility/graph.py new file mode 100644 index 000000000..5176281b4 --- /dev/null +++ b/pyocd/utility/graph.py @@ -0,0 +1,92 @@ +# pyOCD debugger +# Copyright (c) 2019 Arm Limited +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +class GraphNode(object): + """! @brief Simple graph node.""" + + def __init__(self): + """! @brief Constructor.""" + super(GraphNode, self).__init__() + self._parent = None + self._children = [] + + @property + def parent(self): + """! @brief This node's parent in the object graph.""" + return self._parent + + @property + def children(self): + """! @brief Child nodes in the object graph.""" + return self._children + + def add_child(self, node): + """! @brief Link a child node onto this object.""" + node._parent = self + self._children.append(node) + + def find_children(self, predicate, breadth_first=True): + """! @brief Recursively search for children that match a given predicate. + @param self + @param predicate A callable accepting a single argument for the node to examine. If the + predicate returns True, then that node is added to the result list and no further + searches on that node's children are performed. A False predicate result causes the + node's children to be searched. + @param breadth_first Whether to search breadth first. Pass False to search depth first. + @returns List of matching child nodes, or an empty list if no matches were found. + """ + def _search(node, klass): + results = [] + childrenToExamine = [] + for child in node.children: + if predicate(child): + results.append(child) + elif not breadth_first: + results.extend(_search(child, klass)) + elif breadth_first: + childrenToExamine.append(child) + + if breadth_first: + for child in childrenToExamine: + results.extend(_search(child, klass)) + return results + + return _search(self, predicate) + + def get_first_child_of_type(self, klass): + """! @brief Breadth-first search for a child of the given class. + @param self + @param klass The class type to search for. The first child at any depth that is an instance + of this class or a subclass thereof will be returned. Matching children at more shallow + nodes will take precedence over deeper nodes. + @returns Either a node object or None. + """ + matches = self.find_children(lambda c: isinstance(c, klass)) + if len(matches): + return matches[0] + else: + return None + +def dump_graph(node): + """! @brief Draw the object graph.""" + + def _dump(node, level): + name = node.__class__.__name__ + print(" " * level + "- " + name) + for child in node.children: + _dump(child, level + 1) + + _dump(node, 0)	diff --git a/pyocd/test/test_graph.py b/pyocd/test/test_graph.py new file mode 100644 index 000000000..c5a81ceb0 --- /dev/null +++ b/pyocd/test/test_graph.py @@ -0,0 +1,110 @@ +# pyOCD debugger +# Copyright (c) 2019 Arm Limited +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from pyocd.utility.graph import GraphNode +import pytest + +class BaseNode(GraphNode): + def __init__(self, value): + super(BaseNode, self).__init__() + self.value = value + + def __repr__(self): + return "<{}@{:#010x} {}".format(self.__class__.__name__, id(self), self.value) + +class NodeA(BaseNode): + pass + +class NodeB(BaseNode): + pass + +@pytest.fixture(scope='function') +def a(): + return NodeA(23) + +@pytest.fixture(scope='function') +def b(): + return NodeB(1) + +@pytest.fixture(scope='function') +def c(): + return NodeB(2) + +@pytest.fixture(scope='function') +def graph(a, b, c): + p = GraphNode() + p.add_child(a) + a.add_child(b) + p.add_child(c) + return p + +class TestGraph: + def test_new(self): + n = GraphNode() + assert len(n.children) == 0 + assert n.parent is None + + def test_add_child(self): + p = GraphNode() + a = GraphNode() + p.add_child(a) + assert p.children == [a] + assert p.parent is None + assert a.parent is p + assert a.children == [] + + def test_multiple_child(self): + p = GraphNode() + a = GraphNode() + b = GraphNode() + c = GraphNode() + p.add_child(a) + p.add_child(b) + p.add_child(c) + assert p.children == [a, b, c] + assert p.parent is None + assert a.parent is p + assert b.parent is p + assert c.parent is p + assert a.children == [] + assert b.children == [] + assert c.children == [] + + def test_multilevel(self, graph, a, b, c): + assert len(graph.children) == 2 + assert graph.children == [a, c] + assert len(a.children) == 1 + assert a.children == [b] + assert graph.parent is None + assert a.parent is graph + assert b.parent is a + assert c.parent is graph + assert b.children == [] + assert c.children == [] + + def test_find_breadth(self, graph, a, b, c): + assert graph.find_children(lambda n: n.value == 1) == [b] + assert graph.find_children(lambda n: n.value == 1 or n.value == 2) == [c, b] + + def test_find_depth(self, graph, a, b, c): + assert graph.find_children(lambda n: n.value == 1, breadth_first=False) == [b] + assert graph.find_children(lambda n: n.value == 1 or n.value == 2, breadth_first=False) == [b, c] + + def test_first(self, graph, a, b, c): + assert graph.get_first_child_of_type(NodeA) == a + assert graph.get_first_child_of_type(NodeB) == c + assert a.get_first_child_of_type(NodeB) == b +		[ { "components": [ { "doc": "", "lines": [ 433, 440 ], "name": "CortexM.add_child", "signature": "def add_child(self, cmp):", "type": "function" } ], "file": "pyocd/coresight/cortex_m.py" }, { "components": [ { ...	[ "pyocd/test/test_graph.py::TestGraph::test_new", "pyocd/test/test_graph.py::TestGraph::test_add_child", "pyocd/test/test_graph.py::TestGraph::test_multiple_child", "pyocd/test/test_graph.py::TestGraph::test_multilevel", "pyocd/test/test_graph.py::TestGraph::test_find_breadth", "pyocd/test/test_graph.py::T...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Generic object graph This PR creates a more explicit graph out of the various objects in a session. A `GraphNode` base class is added that provides parent and child links, plus a couple methods to search for children. The goal here is to make the relationships between objects more apparent, and to make it easier to find various objects as the graph becomes more complicated with additional CoreSight components being supported. Classes will still have explicit references to the other objects they need to function, such as the `fpb` and `dwt` attributes on `CortexM`. But it is now possible to connect other components in the graph even if the parent doesn't directly use or support the child, for instance ITM or TPIU being associated with a core. Finally, this makes it easier to find components if they move around in the graph due to different CoreSight configurations, such as a TPIU being shared between multiple cores versus being attached directly to a single core. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pyocd/coresight/cortex_m.py] (definition of CortexM.add_child:) def add_child(self, cmp): [end of new definitions in pyocd/coresight/cortex_m.py] [start of new definitions in pyocd/utility/graph.py] (definition of GraphNode:) class GraphNode(object): """! @brief Simple graph node.""" (definition of GraphNode.__init__:) def __init__(self): """! @brief Constructor.""" (definition of GraphNode.parent:) def parent(self): """! @brief This node's parent in the object graph.""" (definition of GraphNode.children:) def children(self): """! @brief Child nodes in the object graph.""" (definition of GraphNode.add_child:) def add_child(self, node): """! @brief Link a child node onto this object.""" (definition of GraphNode.find_children:) def find_children(self, predicate, breadth_first=True): """! @brief Recursively search for children that match a given predicate. @param self @param predicate A callable accepting a single argument for the node to examine. If the predicate returns True, then that node is added to the result list and no further searches on that node's children are performed. A False predicate result causes the node's children to be searched. @param breadth_first Whether to search breadth first. Pass False to search depth first. @returns List of matching child nodes, or an empty list if no matches were found.""" (definition of GraphNode.find_children._search:) def _search(node, klass): (definition of GraphNode.get_first_child_of_type:) def get_first_child_of_type(self, klass): """! @brief Breadth-first search for a child of the given class. @param self @param klass The class type to search for. The first child at any depth that is an instance of this class or a subclass thereof will be returned. Matching children at more shallow nodes will take precedence over deeper nodes. @returns Either a node object or None.""" (definition of dump_graph:) def dump_graph(node): """! @brief Draw the object graph.""" (definition of dump_graph._dump:) def _dump(node, level): [end of new definitions in pyocd/utility/graph.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		fe7d737424be818daa1d55ecbd59be1a0dffdf5b
sympy__sympy-15994	15,994	sympy/sympy	1.4	6f6707f96a51db7d49f59d0e26d2df95acbfc33f	2019-02-15T19:56:26Z	diff --git a/sympy/matrices/expressions/matadd.py b/sympy/matrices/expressions/matadd.py index 22315096ce33..1c28021249ed 100644 --- a/sympy/matrices/expressions/matadd.py +++ b/sympy/matrices/expressions/matadd.py @@ -8,8 +8,9 @@ from sympy.matrices.matrices import MatrixBase from sympy.matrices.expressions.transpose import transpose from sympy.strategies import (rm_id, unpack, flatten, sort, condition, - exhaust, do_one, glom) -from sympy.matrices.expressions.matexpr import MatrixExpr, ShapeError, ZeroMatrix + exhaust, do_one, glom) +from sympy.matrices.expressions.matexpr import (MatrixExpr, ShapeError, + ZeroMatrix, GenericZeroMatrix) from sympy.utilities import default_sort_key, sift from sympy.core.operations import AssocOp @@ -32,6 +33,12 @@ class MatAdd(MatrixExpr, Add): is_MatAdd = True def __new__(cls, args, kwargs): + if not args: + return GenericZeroMatrix() + + # This must be removed aggressively in the constructor to avoid + # TypeErrors from GenericZeroMatrix().shape + args = filter(lambda i: GenericZeroMatrix() != i, args) args = list(map(sympify, args)) check = kwargs.get('check', False) diff --git a/sympy/matrices/expressions/matexpr.py b/sympy/matrices/expressions/matexpr.py index 124e9994e25e..69124d89fe7a 100644 --- a/sympy/matrices/expressions/matexpr.py +++ b/sympy/matrices/expressions/matexpr.py @@ -738,6 +738,10 @@ def cols(self): def shape(self): return (self.args[0], self.args[0]) + @property + def is_square(self): + return True + def _eval_transpose(self): return self @@ -761,6 +765,39 @@ def _entry(self, i, j, kwargs): def _eval_determinant(self): return S.One +class GenericIdentity(Identity): + """ + An identity matrix without a specified shape + + This exists primarily so MatMul() with no arguments can return something + meaningful. + """ + def __new__(cls): + # super(Identity, cls) instead of super(GenericIdentity, cls) because + # Identity.__new__ doesn't have the same signature + return super(Identity, cls).__new__(cls) + + @property + def rows(self): + raise TypeError("GenericIdentity does not have a specified shape") + + @property + def cols(self): + raise TypeError("GenericIdentity does not have a specified shape") + + @property + def shape(self): + raise TypeError("GenericIdentity does not have a specified shape") + + # Avoid Matrix.__eq__ which might call .shape + def __eq__(self, other): + return isinstance(other, GenericIdentity) + + def __ne__(self, other): + return not (self == other) + + def __hash__(self): + return super(GenericIdentity, self).__hash__() class ZeroMatrix(MatrixExpr): """The Matrix Zero 0 - additive identity @@ -816,6 +853,40 @@ def __nonzero__(self): __bool__ = __nonzero__ +class GenericZeroMatrix(ZeroMatrix): + """ + A zero matrix without a specified shape + + This exists primarily so MatAdd() with no arguments can return something + meaningful. + """ + def __new__(cls): + # super(ZeroMatrix, cls) instead of super(GenericZeroMatrix, cls) + # because ZeroMatrix.__new__ doesn't have the same signature + return super(ZeroMatrix, cls).__new__(cls) + + @property + def rows(self): + raise TypeError("GenericZeroMatrix does not have a specified shape") + + @property + def cols(self): + raise TypeError("GenericZeroMatrix does not have a specified shape") + + @property + def shape(self): + raise TypeError("GenericZeroMatrix does not have a specified shape") + + # Avoid Matrix.__eq__ which might call .shape + def __eq__(self, other): + return isinstance(other, GenericZeroMatrix) + + def __ne__(self, other): + return not (self == other) + + + def __hash__(self): + return super(GenericZeroMatrix, self).__hash__() def matrix_symbols(expr): return [sym for sym in expr.free_symbols if sym.is_Matrix] diff --git a/sympy/matrices/expressions/matmul.py b/sympy/matrices/expressions/matmul.py index fb861a70bafb..cff91f73f708 100644 --- a/sympy/matrices/expressions/matmul.py +++ b/sympy/matrices/expressions/matmul.py @@ -8,7 +8,7 @@ from sympy.strategies import (rm_id, unpack, typed, flatten, exhaust, do_one, new) from sympy.matrices.expressions.matexpr import (MatrixExpr, ShapeError, - Identity, ZeroMatrix) + Identity, ZeroMatrix, GenericIdentity) from sympy.matrices.expressions.matpow import MatPow from sympy.matrices.matrices import MatrixBase @@ -31,12 +31,22 @@ class MatMul(MatrixExpr, Mul): def __new__(cls, args, *kwargs): check = kwargs.get('check', True) + + if not args: + return GenericIdentity() + + # This must be removed aggressively in the constructor to avoid + # TypeErrors from GenericIdentity().shape + args = filter(lambda i: GenericIdentity() != i, args) args = list(map(sympify, args)) obj = Basic.__new__(cls, args) factor, matrices = obj.as_coeff_matrices() if check: validate(*matrices) if not matrices: + # Should it be + # + # return Basic.__neq__(cls, factor, GenericIdentity()) ? return factor return obj	diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index dc98b2191cf1..5895f1ca842c 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -2666,6 +2666,9 @@ def test_sympy__matrices__expressions__matexpr__Identity(): from sympy.matrices.expressions.matexpr import Identity assert _test_args(Identity(3)) +def test_sympy__matrices__expressions__matexpr__GenericIdentity(): + from sympy.matrices.expressions.matexpr import GenericIdentity + assert _test_args(GenericIdentity()) @SKIP("abstract class") def test_sympy__matrices__expressions__matexpr__MatrixExpr(): @@ -2686,6 +2689,9 @@ def test_sympy__matrices__expressions__matexpr__ZeroMatrix(): from sympy.matrices.expressions.matexpr import ZeroMatrix assert _test_args(ZeroMatrix(3, 5)) +def test_sympy__matrices__expressions__matexpr__GenericZeroMatrix(): + from sympy.matrices.expressions.matexpr import GenericZeroMatrix + assert _test_args(GenericZeroMatrix()) def test_sympy__matrices__expressions__matmul__MatMul(): from sympy.matrices.expressions.matmul import MatMul diff --git a/sympy/matrices/expressions/tests/test_matexpr.py b/sympy/matrices/expressions/tests/test_matexpr.py index ace95c2802fb..21c92ea8e8fc 100644 --- a/sympy/matrices/expressions/tests/test_matexpr.py +++ b/sympy/matrices/expressions/tests/test_matexpr.py @@ -8,7 +8,8 @@ from sympy.matrices import (Identity, ImmutableMatrix, Inverse, MatAdd, MatMul, MatPow, Matrix, MatrixExpr, MatrixSymbol, ShapeError, ZeroMatrix, SparseMatrix, Transpose, Adjoint) -from sympy.matrices.expressions.matexpr import MatrixElement +from sympy.matrices.expressions.matexpr import (MatrixElement, + GenericZeroMatrix, GenericIdentity) from sympy.utilities.pytest import raises @@ -360,3 +361,42 @@ def test_issue_2749(): def test_issue_2750(): x = MatrixSymbol('x', 1, 1) assert (x.Tx).as_explicit()-1 == Matrix([[x[0, 0](-2)]]) + +def test_generic_zero_matrix(): + z = GenericZeroMatrix() + A = MatrixSymbol("A", n, n) + + assert z == z + assert z != A + assert A != z + + assert z.is_ZeroMatrix + + raises(TypeError, lambda: z.shape) + raises(TypeError, lambda: z.rows) + raises(TypeError, lambda: z.cols) + + assert MatAdd() == z + assert MatAdd(z, A) == MatAdd(A) + # Make sure it is hashable + hash(z) + +def test_generic_identity(): + I = GenericIdentity() + A = MatrixSymbol("A", n, n) + + assert I == I + assert I != A + assert A != I + + assert I.is_Identity + assert I*-1 == I + + raises(TypeError, lambda: I.shape) + raises(TypeError, lambda: I.rows) + raises(TypeError, lambda: I.cols) + + assert MatMul() == I + assert MatMul(I, A) == MatMul(A) + # Make sure it is hashable + hash(I)		[ { "components": [ { "doc": "", "lines": [ 742, 743 ], "name": "Identity.is_square", "signature": "def is_square(self):", "type": "function" }, { "doc": "An identity matrix without a specified shape\n\nThis exists prima...	[ "test_sympy__matrices__expressions__matexpr__GenericIdentity", "test_sympy__matrices__expressions__matexpr__GenericZeroMatrix", "test_shape", "test_matexpr", "test_subs", "test_ZeroMatrix", "test_ZeroMatrix_doit", "test_Identity", "test_Identity_doit", "test_addition", "test_multiplication", "...	[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add GenericZeroMatrix and GenericIdentity class in matrix expressions These are generic in the sense that they have no shape (.shape raises a TypeError). They are returned by MatAdd() and MatMul() with no arguments. In order to avoid the TypeErrors being an issue, MatAdd and MatMul remove them unconditionally in their constructors (normally they are completely unevaluated without calling doit()). closes #15986 as an alternative. See the discussion there and at https://github.com/sympy/sympy/pull/15948#issuecomment-463432718. <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * matrices * `MatAdd()` and `MatMul()` now return generic zero and identity matrices with no specified shape. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/matrices/expressions/matexpr.py] (definition of Identity.is_square:) def is_square(self): (definition of GenericIdentity:) class GenericIdentity(Identity): """An identity matrix without a specified shape This exists primarily so MatMul() with no arguments can return something meaningful.""" (definition of GenericIdentity.__new__:) def __new__(cls): (definition of GenericIdentity.rows:) def rows(self): (definition of GenericIdentity.cols:) def cols(self): (definition of GenericIdentity.shape:) def shape(self): (definition of GenericIdentity.__eq__:) def __eq__(self, other): (definition of GenericIdentity.__ne__:) def __ne__(self, other): (definition of GenericIdentity.__hash__:) def __hash__(self): (definition of GenericZeroMatrix:) class GenericZeroMatrix(ZeroMatrix): """A zero matrix without a specified shape This exists primarily so MatAdd() with no arguments can return something meaningful.""" (definition of GenericZeroMatrix.__new__:) def __new__(cls): (definition of GenericZeroMatrix.rows:) def rows(self): (definition of GenericZeroMatrix.cols:) def cols(self): (definition of GenericZeroMatrix.shape:) def shape(self): (definition of GenericZeroMatrix.__eq__:) def __eq__(self, other): (definition of GenericZeroMatrix.__ne__:) def __ne__(self, other): (definition of GenericZeroMatrix.__hash__:) def __hash__(self): [end of new definitions in sympy/matrices/expressions/matexpr.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Add UndefinedMatrixShapeSymbol class This can be used as a symbolic shape in a matrix expression, and will not result in errors when compared to a different shape. For instance, _n = UndefinedMatrixShapeSymbol('_n') k = Symbol('k') A = MatrixSymbol("A", _n, _n) B = MatrixSymbol("B", k, k) A + B # does not result in an error In particular, MatAdd() and MatMul() with no arguments now return a ZeroMatrix and Identity with Dummy UndefinedMatrixShapeSymbol, rather than scalar 0 and 1. Also makes it so that is_square returns None if one of the arguments has an UndefinedMatrixShapeSymbol. I'm still not 100% sure if this is a good idea. I'd like feedback on it. It does fix the issue described at https://github.com/sympy/sympy/pull/15948#issuecomment-463432718. Although with it, `cancel` returns matrices with unevaluated `0` and `I` matrices, so we probably should add better automatic simplification of these. <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> #### Brief description of what is fixed or changed #### Other comments #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * matrices * new class in `sympy.matrices.expressions.matexpr`, `UndefinedMatrixShapeSymbol`, which can be used in symbolic matrix shapes to not compare unequal to other matrix shapes for the purposes of type checking. * `MatAdd()` and `MatMul()` with no arguments now return `ZeroMatrix` and `Identity` with Dummy `UndefinedMatrixShapeSymbol`, resp. * `MatrixExpr.is_square` returns `None` if the shape contains an `UndefinedMatrixShapeSymbol`. <!-- END RELEASE NOTES --> ---------- Another alternative to this would be to simply be less aggressive with type checking in the matrix expressions. I think that would be a much harder change, and we do want to do type checking at some point, so it's not clear where it should be done and not done. I wonder if we could have a Chameleon (Symbol) which always passes `Eq(Chameleon(), foo)` but not `Eq(Chameleon(), Chameleon())`? Being always equal to everything could cause issues. It could get swapped out for things that SymPy thinks it is equal to. For instance it would be impossible to `subs` the chameleon with something else because subs would think the first expression it comes across is equal to it. > could cause issues crumple, crumple, toss. We have PurePoly with a common symbol. Could we have a Symbol that is recognized as being an arbitrary integer: `IntSymbol('n') == IntSymbol('n') != IntSymbol('m')`? I'm not sure about it. We really only need to bypass the type checks, which are basically three places in the code, the check that the shapes are equal in MatAdd, the check that rows == cols in MatMul, and the check for is_square in Inverse. To take a step back, the problem that we are trying to solve is to make matrix expressions work with any function that already works with noncommutative Symbols. The problem is that MatAdd and MatMul subclass from Add and Mul, but there are some ways that they don't behave the same, leading to errors from any algorithm that assumes they do. One of these ways is that you can't add 0 to a matrix expression, because 0 is a scalar and doesn't have the proper shape. You also can't create an empty `MatAdd()` or `MatMul()`, which causes issues with functions like the one in https://github.com/sympy/sympy/pull/15948#issuecomment-463432718 which call `expr.func(*l)` where `l` could be empty. For `Add()` and `Mul()` those are obviously the identities `0` and `1`, but for `MatAdd()` and `MatMul()` the exact identity depends on the shape of the matrix. Actually, since this is really only needed for ZeroMatrix and Identity, maybe instead of doing this with the shape parameter, we could create special ZeroMatrix and Identity objects that don't have a specified shape (the `.shape` could raise an exception). As long as these are aggressively removed once they are part of a larger expression, it might work. By "aggressively" I mean MatAdd and MatMul should remove them even without calling `doit` (unlike `Add` and `Mul`,`MatAdd` and `MatMul` are completely unevaluated by default). Would it suffice to define two special matrix expressions, `MatZero` and `MatOne`? -------------------- </issues>	e941ad69638189ea42507331e417b88837357dec
falconry__falcon-1447	1,447	falconry/falcon	null	35d5220c7ee359ac6b03788107a194644eb00344	2019-02-14T07:30:05Z	diff --git a/CHANGES.rst b/CHANGES.rst index bf705ab82..54c3a289a 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -61,6 +61,9 @@ Breaking Changes Falcon detects that it is running on the wsgiref server. If you need to normalize stream semantics between wsgiref and a production WSGI server, ``Request.bounded_stream`` may be used instead. +- ``Request.cookies`` now gives precedence to the first value + encountered in the Cookie header for a given cookie name, rather than the + last. Changes to Supported Platforms ------------------------------ @@ -109,6 +112,11 @@ New & Improved ``dumps()`` and ``loads()`` functions. This enables support not only for using any of a number of third-party JSON libraries, but also for customizing the keyword arguments used when (de)serializing objects. +- Added a new method, ``get_cookie_values()``, to the ``Request`` + class. The new method supports getting all values provided for a given + cookie, and is now the preferred mechanism for reading request cookies. +- Optimized request cookie parsing. It is now roughly an order of magnitude + faster. - ``append_header()`` now supports appending raw Set-Cookie header values. Fixed diff --git a/docs/api/cookies.rst b/docs/api/cookies.rst index dbfc918bf..828780c08 100644 --- a/docs/api/cookies.rst +++ b/docs/api/cookies.rst @@ -3,15 +3,16 @@ Cookies ------- -Cookie support is available in Falcon version 0.3 or later. - .. _getting-cookies: Getting Cookies ~~~~~~~~~~~~~~~ -Cookies can be read from a request via the :py:attr:`~.Request.cookies` -request attribute: +Cookies can be read from a request either via the +:py:meth:`~.Request.get_cookie_values` method or the :py:attr:`~.Request.cookies` +attribute on the :py:class:`~.Request` object. Generally speaking, the +:py:meth:`~.Request.get_cookie_values` method should be used unless you need a +collection of all the cookies in the request. .. code:: python @@ -20,13 +21,13 @@ request attribute: cookies = req.cookies - if 'my_cookie' in cookies: - my_cookie_value = cookies['my_cookie'] - # .... + my_cookie_values = req.get_cookie_values('my_cookie') + if my_cookie_values: + # NOTE: If there are multiple values set for the cookie, you + # will need to choose how to handle the additional values. + v = my_cookie_values[0] -The :py:attr:`~.Request.cookies` attribute is a regular -:py:class:`dict` object. The returned object should be treated as -read-only to avoid unintended side-effects. + # ... .. _setting-cookies: diff --git a/docs/changes/2.0.0.rst b/docs/changes/2.0.0.rst index b9f5c8977..60effcdaf 100644 --- a/docs/changes/2.0.0.rst +++ b/docs/changes/2.0.0.rst @@ -64,6 +64,9 @@ Breaking Changes stream when Falcon detects that it is running on the wsgiref server. If you need to normalize stream semantics between wsgiref and a production WSGI server, :attr:`~.Request.bounded_stream` may be used instead. +- :attr:`falcon.Request.cookies` now gives precedence to the first value + encountered in the Cookie header for a given cookie name, rather than the + last. Changes to Supported Platforms ------------------------------ @@ -120,6 +123,12 @@ New & Improved ``dumps()`` and ``loads()`` functions. This enables support not only for using any of a number of third-party JSON libraries, but also for customizing the keyword arguments used when (de)serializing objects. +- Added a new method, :meth:`~.Request.get_cookie_values`, to the + :class:`~.Request` class. The new method supports getting all values + provided for a given cookie, and is now the preferred mechanism for + reading request cookies. +- Optimized request cookie parsing. It is now roughly an order of magnitude + faster. - :meth:`~.Response.append_header` now supports appending raw Set-Cookie header values. Fixed diff --git a/falcon/request.py b/falcon/request.py index c3a69ed16..4e6ae7636 100644 --- a/falcon/request.py +++ b/falcon/request.py @@ -27,11 +27,6 @@ from falcon.util.uri import parse_host, parse_query_string from falcon.vendor import mimeparse -# NOTE(tbug): In some cases, compat.http_cookies is not a module -# but a dict-like structure. This fixes that issue. -# See issue https://github.com/falconry/falcon/issues/556 -SimpleCookie = compat.http_cookies.SimpleCookie - DEFAULT_ERROR_LOG_FORMAT = (u'{0:%Y-%m-%d %H:%M:%S} [FALCON] [ERROR]' u' {1} {2}{3} => ') @@ -256,8 +251,12 @@ class Request(object): client_accepts_xml (bool): ``True`` if the Accept header indicates that the client is willing to receive XML, otherwise ``False``. cookies (dict): - A dict of name/value cookie pairs. (See also: - :ref:`Getting Cookies <getting-cookies>`) + A dict of name/value cookie pairs. The returned object should be + treated as read-only to avoid unintended side-effects. + If a cookie appears more than once in the request, only the first + value encountered will be made available here. + + See also: :meth:`~get_cookie_values` content_type (str): Value of the Content-Type header, or ``None`` if the header is missing. content_length (int): Value of the Content-Length header converted @@ -394,7 +393,6 @@ class Request(object): '_cached_prefix', '_cached_relative_uri', '_cached_uri', - '_cookies', '_params', '_wsgierrors', 'content_type', @@ -409,6 +407,9 @@ class Request(object): '_media', ) + _cookies = None + _cookies_collapsed = None + # Child classes may override this context_type = type('RequestContext', (dict,), {}) @@ -456,8 +457,6 @@ def __init__(self, env, options=None): else: self._params = {} - self._cookies = None - self._cached_access_route = None self._cached_forwarded = None self._cached_forwarded_prefix = None @@ -825,24 +824,17 @@ def params(self): @property def cookies(self): - if self._cookies is None: - # NOTE(tbug): We might want to look into parsing - # cookies ourselves. The SimpleCookie is doing a - # lot if stuff only required to SEND cookies. - cookie_header = self.get_header('Cookie', default='') - parser = SimpleCookie() - for cookie_part in cookie_header.split('; '): - try: - parser.load(cookie_part) - except compat.http_cookies.CookieError: - pass - cookies = {} - for morsel in parser.values(): - cookies[morsel.key] = morsel.value + if self._cookies_collapsed is None: + if self._cookies is None: + header_value = self.get_header('Cookie') + if header_value: + self._cookies = helpers.parse_cookie_header(header_value) + else: + self._cookies = {} - self._cookies = cookies + self._cookies_collapsed = {n: v[0] for n, v in self._cookies.items()} - return self._cookies + return self._cookies_collapsed @property def access_route(self): @@ -1077,6 +1069,37 @@ def get_header_as_datetime(self, header, required=False, obs_date=False): 'Section 7.1.1.1') raise errors.HTTPInvalidHeader(msg, header) + def get_cookie_values(self, name): + """Return all values provided in the Cookie header for the named cookie. + + (See also: :ref:`Getting Cookies <getting-cookies>`) + + Args: + name (str): Cookie name, case-sensitive. + + Returns: + list: Ordered list of all values specified in the Cookie header for + the named cookie, or ``None`` if the cookie was not included in + the request. If the cookie is specified more than once in the + header, the returned list of values will preserve the ordering of + the individual ``cookie-pair``'s in the header. + """ + + if self._cookies is None: + # PERF(kgriffs): While this code isn't exactly DRY (the same code + # is duplicated by the cookies property) it does make things a bit + # more performant by removing the extra function call that would + # be required to factor this out. If we ever have to do this in a + # third place, we would probably want to factor it out at that + # point. + header_value = self.get_header('Cookie') + if header_value: + self._cookies = helpers.parse_cookie_header(header_value) + else: + self._cookies = {} + + return self._cookies.get(name) + def get_param(self, name, required=False, store=None, default=None): """Return the raw value of a query string parameter as a string. diff --git a/falcon/request_helpers.py b/falcon/request_helpers.py index 13b9a1e1b..421b20e99 100644 --- a/falcon/request_helpers.py +++ b/falcon/request_helpers.py @@ -15,6 +15,78 @@ """Utilities for the Request class.""" import io +import re + +from falcon.util.compat import http_cookies + +# https://tools.ietf.org/html/rfc6265#section-4.1.1 +# +# NOTE(kgriffs): Fortunately we don't have to worry about code points in +# header strings outside the range 0x0000 - 0x00FF per PEP 3333 +# (see also: https://www.python.org/dev/peps/pep-3333/#unicode-issues) +# +_COOKIE_NAME_RESERVED_CHARS = re.compile('[\x00-\x1F\x7F-\xFF()<>@,;:\\\\"/[\\]?={} \x09]') + + +def parse_cookie_header(header_value): + """Parse a Cookie header value into a dict of named values. + + (See also: RFC 6265, Section 5.4) + + Args: + header_value (str): Value of a Cookie header + + Returns: + dict: Map of cookie names to a list of all cookie values found in the + header for that name. If a cookie is specified more than once in the + header, the order of the values will be preserved. + """ + + # See also: + # + # https://tools.ietf.org/html/rfc6265#section-5.4 + # https://tools.ietf.org/html/rfc6265#section-4.1.1 + # + + cookies = {} + + for token in header_value.split(';'): + name, __, value = token.partition('=') + + # NOTE(kgriffs): RFC6265 is more strict about whitespace, but we + # are more lenient here to better handle old user agents and to + # mirror Python's standard library cookie parsing behavior + name = name.strip() + value = value.strip() + + # NOTE(kgriffs): Skip malformed cookie-pair + if not name: + continue + + # NOTE(kgriffs): Skip cookies with invalid names + if _COOKIE_NAME_RESERVED_CHARS.search(name): + continue + + # NOTE(kgriffs): To maximize compatibility, we mimic the support in the + # standard library for escaped characters within a double-quoted + # cookie value according to the obsolete RFC 2109. However, we do not + # expect to see this encoding used much in practice, since Base64 is + # the current de-facto standard, as recommended by RFC 6265. + # + # PERF(kgriffs): These checks have been hoisted from within _unquote() + # to avoid the extra function call in the majority of the cases when it + # is not needed. + if len(value) > 2 and value[0] == '"' and value[-1] == '"': + value = http_cookies._unquote(value) + + # PERF(kgriffs): This is slightly more performant as + # compared to using dict.setdefault() + if name in cookies: + cookies[name].append(value) + else: + cookies[name] = [value] + + return cookies def header_property(wsgi_name):	diff --git a/tests/test_cookies.py b/tests/test_cookies.py index 9d34b461e..e0cbfcf90 100644 --- a/tests/test_cookies.py +++ b/tests/test_cookies.py @@ -241,7 +241,9 @@ def test_request_cookie_parsing(): 'Cookie', """ logged_in=no;_gh_sess=eyJzZXXzaW9uX2lkIjoiN2; - tz=Europe/Berlin; _ga=GA1.2.332347814.1422308165; + tz=Europe/Berlin; _ga =GA1.2.332347814.1422308165; + tz2=Europe/Paris ; _ga2="line1\\012line2"; + tz3=Europe/Madrid ;_ga3= GA3.2.332347814.1422308165; _gat=1; _octo=GH1.1.201722077.1422308165 """ @@ -251,39 +253,75 @@ def test_request_cookie_parsing(): environ = testing.create_environ(headers=headers) req = falcon.Request(environ) - assert req.cookies['logged_in'] == 'no' - assert req.cookies['tz'] == 'Europe/Berlin' - assert req.cookies['_octo'] == 'GH1.1.201722077.1422308165' - - assert 'logged_in' in req.cookies - assert '_gh_sess' in req.cookies - assert 'tz' in req.cookies - assert '_ga' in req.cookies - assert '_gat' in req.cookies - assert '_octo' in req.cookies + # NOTE(kgriffs): Test case-sensitivity + assert req.get_cookie_values('TZ') is None + assert 'TZ' not in req.cookies + with pytest.raises(KeyError): + req.cookies['TZ'] + + for name, value in [ + ('logged_in', 'no'), + ('_gh_sess', 'eyJzZXXzaW9uX2lkIjoiN2'), + ('tz', 'Europe/Berlin'), + ('tz2', 'Europe/Paris'), + ('tz3', 'Europe/Madrid'), + ('_ga', 'GA1.2.332347814.1422308165'), + ('_ga2', 'line1\nline2'), + ('_ga3', 'GA3.2.332347814.1422308165'), + ('_gat', '1'), + ('_octo', 'GH1.1.201722077.1422308165'), + ]: + assert name in req.cookies + assert req.cookies[name] == value + assert req.get_cookie_values(name) == [value] def test_invalid_cookies_are_ignored(): + vals = [chr(i) for i in range(0x1F)] + vals += [chr(i) for i in range(0x7F, 0xFF)] + vals += '()<>@,;:\\"/[]?={} \x09'.split() + + for c in vals: + headers = [ + ( + 'Cookie', + 'good_cookie=foo;bad' + c + 'cookie=bar' + ), + ] + + environ = testing.create_environ(headers=headers) + req = falcon.Request(environ) + + assert req.cookies['good_cookie'] == 'foo' + assert 'bad' + c + 'cookie' not in req.cookies + + +def test_duplicate_cookie(): headers = [ ( 'Cookie', - """ - good_cookie=foo; - bad{cookie=bar - """ + 'x=1;bad{cookie=bar; x=2;x=3 ; x=4;' ), ] environ = testing.create_environ(headers=headers) req = falcon.Request(environ) - assert req.cookies['good_cookie'] == 'foo' - assert 'bad{cookie' not in req.cookies + assert req.cookies['x'] == '1' + assert req.get_cookie_values('x') == ['1', '2', '3', '4'] def test_cookie_header_is_missing(): environ = testing.create_environ(headers={}) + + req = falcon.Request(environ) + assert req.cookies == {} + assert req.get_cookie_values('x') is None + + # NOTE(kgriffs): Test again with a new object to cover calling in the + # opposite order. req = falcon.Request(environ) + assert req.get_cookie_values('x') is None assert req.cookies == {}	diff --git a/CHANGES.rst b/CHANGES.rst index bf705ab82..54c3a289a 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -61,6 +61,9 @@ Breaking Changes Falcon detects that it is running on the wsgiref server. If you need to normalize stream semantics between wsgiref and a production WSGI server, ``Request.bounded_stream`` may be used instead. +- ``Request.cookies`` now gives precedence to the first value + encountered in the Cookie header for a given cookie name, rather than the + last. Changes to Supported Platforms ------------------------------ @@ -109,6 +112,11 @@ New & Improved ``dumps()`` and ``loads()`` functions. This enables support not only for using any of a number of third-party JSON libraries, but also for customizing the keyword arguments used when (de)serializing objects. +- Added a new method, ``get_cookie_values()``, to the ``Request`` + class. The new method supports getting all values provided for a given + cookie, and is now the preferred mechanism for reading request cookies. +- Optimized request cookie parsing. It is now roughly an order of magnitude + faster. - ``append_header()`` now supports appending raw Set-Cookie header values. Fixed diff --git a/docs/api/cookies.rst b/docs/api/cookies.rst index dbfc918bf..828780c08 100644 --- a/docs/api/cookies.rst +++ b/docs/api/cookies.rst @@ -3,15 +3,16 @@ Cookies ------- -Cookie support is available in Falcon version 0.3 or later. - .. _getting-cookies: Getting Cookies ~~~~~~~~~~~~~~~ -Cookies can be read from a request via the :py:attr:`~.Request.cookies` -request attribute: +Cookies can be read from a request either via the +:py:meth:`~.Request.get_cookie_values` method or the :py:attr:`~.Request.cookies` +attribute on the :py:class:`~.Request` object. Generally speaking, the +:py:meth:`~.Request.get_cookie_values` method should be used unless you need a +collection of all the cookies in the request. .. code:: python @@ -20,13 +21,13 @@ request attribute: cookies = req.cookies - if 'my_cookie' in cookies: - my_cookie_value = cookies['my_cookie'] - # .... + my_cookie_values = req.get_cookie_values('my_cookie') + if my_cookie_values: + # NOTE: If there are multiple values set for the cookie, you + # will need to choose how to handle the additional values. + v = my_cookie_values[0] -The :py:attr:`~.Request.cookies` attribute is a regular -:py:class:`dict` object. The returned object should be treated as -read-only to avoid unintended side-effects. + # ... .. _setting-cookies: diff --git a/docs/changes/2.0.0.rst b/docs/changes/2.0.0.rst index b9f5c8977..60effcdaf 100644 --- a/docs/changes/2.0.0.rst +++ b/docs/changes/2.0.0.rst @@ -64,6 +64,9 @@ Breaking Changes stream when Falcon detects that it is running on the wsgiref server. If you need to normalize stream semantics between wsgiref and a production WSGI server, :attr:`~.Request.bounded_stream` may be used instead. +- :attr:`falcon.Request.cookies` now gives precedence to the first value + encountered in the Cookie header for a given cookie name, rather than the + last. Changes to Supported Platforms ------------------------------ @@ -120,6 +123,12 @@ New & Improved ``dumps()`` and ``loads()`` functions. This enables support not only for using any of a number of third-party JSON libraries, but also for customizing the keyword arguments used when (de)serializing objects. +- Added a new method, :meth:`~.Request.get_cookie_values`, to the + :class:`~.Request` class. The new method supports getting all values + provided for a given cookie, and is now the preferred mechanism for + reading request cookies. +- Optimized request cookie parsing. It is now roughly an order of magnitude + faster. - :meth:`~.Response.append_header` now supports appending raw Set-Cookie header values. Fixed	[ { "components": [ { "doc": "Return all values provided in the Cookie header for the named cookie.\n\n(See also: :ref:`Getting Cookies <getting-cookies>`)\n\nArgs:\n name (str): Cookie name, case-sensitive.\n\nReturns:\n list: Ordered list of all values specified in the Cookie header for\n ...	[ "tests/test_cookies.py::test_request_cookie_parsing", "tests/test_cookies.py::test_invalid_cookies_are_ignored", "tests/test_cookies.py::test_duplicate_cookie", "tests/test_cookies.py::test_cookie_header_is_missing" ]	[ "tests/test_cookies.py::test_response_base_case", "tests/test_cookies.py::test_response_disable_secure_globally", "tests/test_cookies.py::test_response_complex_case", "tests/test_cookies.py::test_cookie_expires_naive", "tests/test_cookies.py::test_cookie_expires_aware", "tests/test_cookies.py::test_cookie...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat(Request): Improve request cookie handling This patch provides support for getting all values for a given cookie (when the same cookie is included multiple times in the request), and also optimizes request cookie parsing to make it an order of magnitude faster. BREAKING CHANGE: Request.cookies now gives precedence to the first value encountered in the Cookie header for a given cookie name, rather than the last. BREAKING CHANGE: Request cookie parsing no longer uses the standard library for most of the parsing logic. This may lead to subtley different results for archaic cookie header formats, since the new implementation is based on the latest RFC 6265. Closes #1107 Closes #1046 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in falcon/request.py] (definition of Request.get_cookie_values:) def get_cookie_values(self, name): """Return all values provided in the Cookie header for the named cookie. (See also: :ref:`Getting Cookies <getting-cookies>`) Args: name (str): Cookie name, case-sensitive. Returns: list: Ordered list of all values specified in the Cookie header for the named cookie, or ``None`` if the cookie was not included in the request. If the cookie is specified more than once in the header, the returned list of values will preserve the ordering of the individual ``cookie-pair``'s in the header.""" [end of new definitions in falcon/request.py] [start of new definitions in falcon/request_helpers.py] (definition of parse_cookie_header:) def parse_cookie_header(header_value): """Parse a Cookie header value into a dict of named values. (See also: RFC 6265, Section 5.4) Args: header_value (str): Value of a Cookie header Returns: dict: Map of cookie names to a list of all cookie values found in the header for that name. If a cookie is specified more than once in the header, the order of the values will be preserved.""" [end of new definitions in falcon/request_helpers.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Multiple cookies with same name in request returns only one This looks like it could be relatively simple fix, but it would involve changing the cookie API a bit. If my browser has two cookies set using the same name - let's call this `_csrf` for example - they are both sent to the server. This is the string returned by `req.get_header("Cookie")`: ``` _csrf=2HBpry7fn6OBCIdS2SnFI-jCdQcq3bt0m03gWgCtjRA; _csrf=Oq_o_Lo_dhhDXqZHQ95NhBp8Nvzntx1FUG-2ryAi6nA ``` However, only one of these is made available in `req.cookies`. It would be preferable to have a method of getting both of these cookies somehow. ---------- We could potentially add a new method, `get_cookie_values()` to handle this case. How else might this be designed? Happy to take suggestions. Thanks for submitting this Gareth, I think this is a helpful request and I appreciate you taking the time to submit it as an issue. I don't think this is something that should be supported as I think it breaks that key-value nature of HTTP Cookies. While the [HTTP cookie spec](https://tools.ietf.org/html/rfc6265#section-5.4) does not prohibit it explicitly, it does use the term `set` which, in a mathematical sense are distinct or unique objects. By adding support for multiple values for a given key, we are no longer working with a set- this would cause deviation from the spec and I do not believe is desirable. As you have mentioned, you can get the raw value for the `Cookie` header by accessing `req.headers` directly. To expand on this a bit, by default Werkzueg (the wsgi layer for Flask) uses `MultiDict`'s base class https://github.com/pallets/werkzeug/blob/e378a8f83d7549904abd7ae5b7ac53491a3c76cf/werkzeug/http.py#L997 which is interesting because the feature is there to support the functionality you are requesting (`MultiDict`) however Flask does not use it. Here is an example flask app which generates the same result as Falcon (the last value in the cookie header for that key). ```python3 import flask app = flask.Flask(__name__) @app.route('/') def index(): print(flask.request.cookies) return '', 200 if __name__ == '__main__': app.run() ``` When I run this HTTP request: ```http GET / HTTP/1.1 Cookie: _csrf=2HBpry7fn6OBCIdS2SnFI-jCdQcq3bt0m03gWgCtjRA; _csrf=Oq_o_Lo_dhhDXqZHQ95NhBp8Nvzntx1FUG-2ryAi6nA Host: localhost:5000 Connection: close User-Agent: Paw/3.1.5 (Macintosh; OS X/10.13.4) GCDHTTPRequest ``` Flask prints `{'_csrf': 'Oq_o_Lo_dhhDXqZHQ95NhBp8Nvzntx1FUG-2ryAi6nA'}` which means it is taking the second value, that seems to be more appropriate behavior and what Falcon is using. What's the consensus on this issue? I agree that it goes against best practice but it could still be helpful for some use cases. I could work on it this weekend but I'll defer to you guys on whether or not it should be adopted. This is an interesting part of [RFC 6265 - 4.2.2](https://tools.ietf.org/html/rfc6265#section-4.2.2): > Although cookies are serialized linearly in the Cookie header, servers SHOULD NOT rely upon the serialization order. In particular, if the Cookie header contains two cookies with the same name (e.g., that were set with different Path or Domain attributes), servers SHOULD NOT rely upon the order in which these cookies appear in the header. However, it does not seem to mention which cookie should take precedence when two are set with the same name. The one with a more specific path? I think in the case given above there is no obvious choice, and therefore it is incorrect usage. I think the answer is still that ONE has to take precedence. It seems falcon chooses based on whatever was added last, which based on the above spec could be interpreted as incorrect; although it does say SHOULD NOT. 😉 Some solutions to the above answer: - There are two csrf tokens, rename them to be more specific `csrf_form1` `csrf_form2` - Concatenate the tokens somehow and encode them in Base64. This is a note from the spec about servers, but could apply to the above issue as well I think. > To maximize compatibility with user agents, servers that wish to store arbitrary data in a cookie-value SHOULD encode that data, for example, using Base64 [RFC4648]. In summary, if we should change anything I think it should be how we determine cookie precedence. -------------------- </issues>	77d5e6394a88ead151c9469494749f95f06b24bf
scikit-learn__scikit-learn-13146	13,146	scikit-learn/scikit-learn	0.22	c0c53137cec61a4d6cd72d8a43bbe0321476e440	2019-02-12T16:33:12Z	diff --git a/doc/inspection.rst b/doc/inspection.rst index 745539d51bf77..b53aeb436b4cd 100644 --- a/doc/inspection.rst +++ b/doc/inspection.rst @@ -5,6 +5,19 @@ Inspection ---------- +Predictive performance is often the main goal of developing machine learning +models. Yet summarising performance with an evaluation metric is often +insufficient: it assumes that the evaluation metric and test dataset +perfectly reflect the target domain, which is rarely true. In certain domains, +a model needs a certain level of interpretability before it can be deployed. +A model that is exhibiting performance issues needs to be debugged for one to +understand the model's underlying issue. The +:mod:`sklearn.inspection` module provides tools to help understand the +predictions from a model and what affects them. This can be used to +evaluate assumptions and biases of a model, design a better model, or +to diagnose issues with model performance. + .. toctree:: modules/partial_dependence + modules/permutation_importance diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index d9c87362e5a11..30fc3b5102bc6 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -657,6 +657,7 @@ Kernels: :template: function.rst inspection.partial_dependence + inspection.permutation_importance inspection.plot_partial_dependence @@ -1257,7 +1258,6 @@ Model validation pipeline.make_pipeline pipeline.make_union - .. _preprocessing_ref: :mod:`sklearn.preprocessing`: Preprocessing and Normalization diff --git a/doc/modules/permutation_importance.rst b/doc/modules/permutation_importance.rst new file mode 100644 index 0000000000000..d1f850ffeb793 --- /dev/null +++ b/doc/modules/permutation_importance.rst @@ -0,0 +1,69 @@ + +.. _permutation_importance: + +Permutation feature importance +============================== + +.. currentmodule:: sklearn.inspection + +Permutation feature importance is a model inspection technique that can be used +for any `fitted` `estimator` when the data is rectangular. This is especially +useful for non-linear or opaque `estimators`. The permutation feature +importance is defined to be the decrease in a model score when a single feature +value is randomly shuffled [1]_. This procedure breaks the relationship between +the feature and the target, thus the drop in the model score is indicative of +how much the model depends on the feature. This technique benefits from being +model agnostic and can be calculated many times with different permutations of +the feature. + +The :func:`permutation_importance` function calculates the feature importance +of `estimators` for a given dataset. The ``n_repeats`` parameter sets the number +of times a feature is randomly shuffled and returns a sample of feature +importances. Permutation importances can either be computed on the training set +or an held-out testing or validation set. Using a held-out set makes it +possible to highlight which features contribute the most to the generalization +power of the inspected model. Features that are important on the training set +but not on the held-out set might cause the model to overfit. + +Note that features that are deemed non-important for some model with a +low predictive performance could be highly predictive for a model that +generalizes better. The conclusions should always be drawn in the context of +the specific model under inspection and cannot be automatically generalized to +the intrinsic predictive value of the features by them-selves. Therefore it is +always important to evaluate the predictive power of a model using a held-out +set (or better with cross-validation) prior to computing importances. + +Relation to impurity-based importance in trees +---------------------------------------------- + +Tree based models provides a different measure of feature importances based +on the mean decrease in impurity (MDI, the splitting criterion). This gives +importance to features that may not be predictive on unseen data. The +permutation feature importance avoids this issue, since it can be applied to +unseen data. Furthermore, impurity-based feature importance for trees +are strongly biased and favor high cardinality features +(typically numerical features). Permutation-based feature importances do not +exhibit such a bias. Additionally, the permutation feature importance may use +an arbitrary metric on the tree's predictions. These two methods of obtaining +feature importance are explored in: +:ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance.py`. + +Strongly correlated features +---------------------------- + +When two features are correlated and one of the features is permuted, the model +will still have access to the feature through its correlated feature. This will +result in a lower importance for both features, where they might actually be +important. One way to handle this is to cluster features that are correlated +and only keep one feature from each cluster. This use case is explored in: +:ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance_multicollinear.py`. + +.. topic:: Examples: + + * :ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance.py` + * :ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance_multicollinear.py` + +.. topic:: References: + + .. [1] L. Breiman, "Random Forests", Machine Learning, 45(1), 5-32, + 2001. https://doi.org/10.1023/A:1010933404324 diff --git a/examples/inspection/plot_permutation_importance.py b/examples/inspection/plot_permutation_importance.py new file mode 100644 index 0000000000000..c449573821a96 --- /dev/null +++ b/examples/inspection/plot_permutation_importance.py @@ -0,0 +1,177 @@ +""" +================================================================ +Permutation Importance vs Random Forest Feature Importance (MDI) +================================================================ + +In this example, we will compare the impurity-based feature importance of +:class:`~sklearn.ensemble.RandomForestClassifier` with the +permutation importance on the titanic dataset using +:func:`~sklearn.inspection.permutation_importance`. We will show that the +impurity-based feature importance can inflate the importance of numerical +features. + +Furthermore, the impurity-based feature importance of random forests suffers +from being computed on statistics derived from the training dataset: the +importances can be high even for features that are not predictive of the target +variable, as long as the model has the capacity to use them to overfit. + +This example shows how to use Permutation Importances as an alternative that +can mitigate those limitations. + +.. topic:: References: + + .. [1] L. Breiman, "Random Forests", Machine Learning, 45(1), 5-32, + 2001. https://doi.org/10.1023/A:1010933404324 +""" +print(__doc__) +import matplotlib.pyplot as plt +import numpy as np + +from sklearn.datasets import fetch_openml +from sklearn.ensemble import RandomForestClassifier +from sklearn.impute import SimpleImputer +from sklearn.inspection import permutation_importance +from sklearn.compose import ColumnTransformer +from sklearn.model_selection import train_test_split +from sklearn.pipeline import Pipeline +from sklearn.preprocessing import OneHotEncoder + + +############################################################################## +# Data Loading and Feature Engineering +# ------------------------------------ +# Let's use pandas to load a copy of the titanic dataset. The following shows +# how to apply separate preprocessing on numerical and categorical features. +# +# We further include two random variables that are not correlated in any way +# with the target variable (``survived``): +# +# - ``random_num`` is a high cardinality numerical variable (as many unique +# values as records). +# - ``random_cat`` is a low cardinality categorical variable (3 possible +# values). +X, y = fetch_openml("titanic", version=1, as_frame=True, return_X_y=True) +X['random_cat'] = np.random.randint(3, size=X.shape[0]) +X['random_num'] = np.random.randn(X.shape[0]) + +categorical_columns = ['pclass', 'sex', 'embarked', 'random_cat'] +numerical_columns = ['age', 'sibsp', 'parch', 'fare', 'random_num'] + +X = X[categorical_columns + numerical_columns] + +X_train, X_test, y_train, y_test = train_test_split( + X, y, stratify=y, random_state=42) + +categorical_pipe = Pipeline([ + ('imputer', SimpleImputer(strategy='constant', fill_value='missing')), + ('onehot', OneHotEncoder(handle_unknown='ignore')) +]) +numerical_pipe = Pipeline([ + ('imputer', SimpleImputer(strategy='mean')) +]) + +preprocessing = ColumnTransformer( + [('cat', categorical_pipe, categorical_columns), + ('num', numerical_pipe, numerical_columns)]) + +rf = Pipeline([ + ('preprocess', preprocessing), + ('classifier', RandomForestClassifier(random_state=42)) +]) +rf.fit(X_train, y_train) + +############################################################################## +# Accuracy of the Model +# --------------------- +# Prior to inspecting the feature importances, it is important to check that +# the model predictive performance is high enough. Indeed there would be little +# interest of inspecting the important features of a non-predictive model. +# +# Here one can observe that the train accuracy is very high (the forest model +# has enough capacity to completely memorize the training set) but it can still +# generalize well enough to the test set thanks to the built-in bagging of +# random forests. +# +# It might be possible to trade some accuracy on the training set for a +# slightly better accuracy on the test set by limiting the capacity of the +# trees (for instance by setting ``min_samples_leaf=5`` or +# ``min_samples_leaf=10``) so as to limit overfitting while not introducing too +# much underfitting. +# +# However let's keep our high capacity random forest model for now so as to +# illustrate some pitfalls with feature importance on variables with many +# unique values. +print("RF train accuracy: %0.3f" % rf.score(X_train, y_train)) +print("RF test accuracy: %0.3f" % rf.score(X_test, y_test)) + + +############################################################################## +# Tree's Feature Importance from Mean Decrease in Impurity (MDI) +# -------------------------------------------------------------- +# The impurity-based feature importance ranks the numerical features to be the +# most important features. As a result, the non-predictive ``random_num`` +# variable is ranked the most important! +# +# This problem stems from two limitations of impurity-based feature +# importances: +# +# - impurity-based importances are biased towards high cardinality features; +# - impurity-based importances are computed on training set statistics and +# therefore do not reflect the ability of feature to be useful to make +# predictions that generalize to the test set (when the model has enough +# capacity). +ohe = (rf.named_steps['preprocess'] + .named_transformers_['cat'] + .named_steps['onehot']) +feature_names = ohe.get_feature_names(input_features=categorical_columns) +feature_names = np.r_[feature_names, numerical_columns] + +tree_feature_importances = ( + rf.named_steps['classifier'].feature_importances_) +sorted_idx = tree_feature_importances.argsort() + +y_ticks = np.arange(0, len(feature_names)) +fig, ax = plt.subplots() +ax.barh(y_ticks, tree_feature_importances[sorted_idx]) +ax.set_yticklabels(feature_names[sorted_idx]) +ax.set_yticks(y_ticks) +ax.set_title("Random Forest Feature Importances (MDI)") +fig.tight_layout() +plt.show() + + +############################################################################## +# As an alternative, the permutation importances of ``rf`` are computed on a +# held out test set. This shows that the low cardinality categorical feature, +# ``sex`` is the most important feature. +# +# Also note that both random features have very low importances (close to 0) as +# expected. +result = permutation_importance(rf, X_test, y_test, n_repeats=10, + random_state=42, n_jobs=2) +sorted_idx = result.importances_mean.argsort() + +fig, ax = plt.subplots() +ax.boxplot(result.importances[sorted_idx].T, + vert=False, labels=X_test.columns[sorted_idx]) +ax.set_title("Permutation Importances (test set)") +fig.tight_layout() +plt.show() + +############################################################################## +# It is also possible to compute the permutation importances on the training +# set. This reveals that ``random_num`` gets a significantly higher importance +# ranking than when computed on the test set. The difference between those two +# plots is a confirmation that the RF model has enough capacity to use that +# random numerical feature to overfit. You can further confirm this by +# re-running this example with constrained RF with min_samples_leaf=10. +result = permutation_importance(rf, X_train, y_train, n_repeats=10, + random_state=42, n_jobs=2) +sorted_idx = result.importances_mean.argsort() + +fig, ax = plt.subplots() +ax.boxplot(result.importances[sorted_idx].T, + vert=False, labels=X_train.columns[sorted_idx]) +ax.set_title("Permutation Importances (train set)") +fig.tight_layout() +plt.show() diff --git a/examples/inspection/plot_permutation_importance_multicollinear.py b/examples/inspection/plot_permutation_importance_multicollinear.py new file mode 100644 index 0000000000000..460de614ed3b2 --- /dev/null +++ b/examples/inspection/plot_permutation_importance_multicollinear.py @@ -0,0 +1,111 @@ +""" +================================================================= +Permutation Importance with Multicollinear or Correlated Features +================================================================= + +In this example, we compute the permutation importance on the Wisconsin +breast cancer dataset using :func:`~sklearn.inspection.permutation_importance`. +The :class:`~sklearn.ensemble.RandomForestClassifier` can easily get about 97% +accuracy on a test dataset. Because this dataset contains multicollinear +features, the permutation importance will show that none of the features are +important. One approach to handling multicollinearity is by performing +hierarchical clustering on the features' Spearman rank-order correlations, +picking a threshold, and keeping a single feature from each cluster. + +.. note:: + See also + :ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance.py` +""" +print(__doc__) +from collections import defaultdict + +import matplotlib.pyplot as plt +import numpy as np +from scipy.stats import spearmanr +from scipy.cluster import hierarchy + +from sklearn.datasets import load_breast_cancer +from sklearn.ensemble import RandomForestClassifier +from sklearn.inspection import permutation_importance +from sklearn.model_selection import train_test_split + +############################################################################## +# Random Forest Feature Importance on Breast Cancer Data +# ------------------------------------------------------ +# First, we train a random forest on the breast cancer dataset and evaluate +# its accuracy on a test set: +data = load_breast_cancer() +X, y = data.data, data.target +X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42) + +clf = RandomForestClassifier(n_estimators=100, random_state=42) +clf.fit(X_train, y_train) +print("Accuracy on test data: {:.2f}".format(clf.score(X_test, y_test))) + +############################################################################## +# Next, we plot the tree based feature importance and the permutation +# importance. The permutation importance plot shows that permuting a feature +# drops the accuracy by at most `0.012`, which would suggest that none of the +# features are important. This is in contradiction with the high test accuracy +# computed above: some feature must be important. The permutation importance +# is calculated on the training set to show how much the model relies on each +# feature during training. +result = permutation_importance(clf, X_train, y_train, n_repeats=10, + random_state=42) +perm_sorted_idx = result.importances_mean.argsort() + +tree_importance_sorted_idx = np.argsort(clf.feature_importances_) +tree_indicies = np.arange(1, len(clf.feature_importances_) + 1) + +fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 8)) +ax1.barh(tree_indicies, clf.feature_importances_[tree_importance_sorted_idx]) +ax1.set_yticklabels(data.feature_names) +ax1.set_yticks(tree_indicies) +ax2.boxplot(result.importances[perm_sorted_idx].T, vert=False, + labels=data.feature_names) +fig.tight_layout() +plt.show() + +############################################################################## +# Handling Multicollinear Features +# -------------------------------- +# When features are collinear, permutating one feature will have little +# effect on the models performance because it can get the same information +# from a correlated feature. One way to handle multicollinear features is by +# performing hierarchical clustering on the Spearman rank-order correlations, +# picking a threshold, and keeping a single feature from each cluster. First, +# we plot a heatmap of the correlated features: +fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 8)) +corr = spearmanr(X).correlation +corr_linkage = hierarchy.ward(corr) +dendro = hierarchy.dendrogram(corr_linkage, labels=data.feature_names, ax=ax1, + leaf_rotation=90) +dendro_idx = np.arange(0, len(dendro['ivl'])) + +ax2.imshow(corr[dendro['leaves'], :][:, dendro['leaves']]) +ax2.set_xticks(dendro_idx) +ax2.set_yticks(dendro_idx) +ax2.set_xticklabels(dendro['ivl'], rotation='vertical') +ax2.set_yticklabels(dendro['ivl']) +fig.tight_layout() +plt.show() + +############################################################################## +# Next, we manually pick a threshold by visual inspection of the dendrogram +# to group our features into clusters and choose a feature from each cluster to +# keep, select those features from our dataset, and train a new random forest. +# The test accuracy of the new random forest did not change much compared to +# the random forest trained on the complete dataset. +cluster_ids = hierarchy.fcluster(corr_linkage, 1, criterion='distance') +cluster_id_to_feature_ids = defaultdict(list) +for idx, cluster_id in enumerate(cluster_ids): + cluster_id_to_feature_ids[cluster_id].append(idx) +selected_features = [v[0] for v in cluster_id_to_feature_ids.values()] + +X_train_sel = X_train[:, selected_features] +X_test_sel = X_test[:, selected_features] + +clf_sel = RandomForestClassifier(n_estimators=100, random_state=42) +clf_sel.fit(X_train_sel, y_train) +print("Accuracy on test data with features removed: {:.2f}".format( + clf_sel.score(X_test_sel, y_test))) diff --git a/sklearn/inspection/__init__.py b/sklearn/inspection/__init__.py index 2bf3fe14c0023..6670e4c576c4d 100644 --- a/sklearn/inspection/__init__.py +++ b/sklearn/inspection/__init__.py @@ -1,9 +1,10 @@ """The :mod:`sklearn.inspection` module includes tools for model inspection.""" from .partial_dependence import partial_dependence from .partial_dependence import plot_partial_dependence - +from .permutation_importance import permutation_importance __all__ = [ 'partial_dependence', 'plot_partial_dependence', + 'permutation_importance' ] diff --git a/sklearn/inspection/permutation_importance.py b/sklearn/inspection/permutation_importance.py new file mode 100644 index 0000000000000..8f63a6c000a36 --- /dev/null +++ b/sklearn/inspection/permutation_importance.py @@ -0,0 +1,126 @@ +"""Permutation importance for estimators""" +import numpy as np +from joblib import Parallel +from joblib import delayed + +from ..metrics import check_scoring +from ..utils import check_random_state +from ..utils import check_array +from ..utils import Bunch + + +def _safe_column_setting(X, col_idx, values): + """Set column on X using `col_idx`""" + if hasattr(X, "iloc"): + X.iloc[:, col_idx] = values + else: + X[:, col_idx] = values + + +def _safe_column_indexing(X, col_idx): + """Return column from X using `col_idx`""" + if hasattr(X, "iloc"): + return X.iloc[:, col_idx].values + else: + return X[:, col_idx] + + +def _calculate_permutation_scores(estimator, X, y, col_idx, random_state, + n_repeats, scorer): + """Calculate score when `col_idx` is permuted.""" + original_feature = _safe_column_indexing(X, col_idx).copy() + temp = original_feature.copy() + + scores = np.zeros(n_repeats) + for n_round in range(n_repeats): + random_state.shuffle(temp) + _safe_column_setting(X, col_idx, temp) + feature_score = scorer(estimator, X, y) + scores[n_round] = feature_score + + _safe_column_setting(X, col_idx, original_feature) + return scores + + +def permutation_importance(estimator, X, y, scoring=None, n_repeats=5, + n_jobs=None, random_state=None): + """Permutation importance for feature evaluation [BRE]_. + + The `estimator` is required to be a fitted estimator. `X` can be the + data set used to train the estimator or a hold-out set. The permutation + importance of a feature is calculated as follows. First, a baseline metric, + defined by `scoring`, is evaluated on a (potentially different) dataset + defined by the `X`. Next, a feature column from the validation set is + permuted and the metric is evaluated again. The permutation importance is + defined to be the difference between the baseline metric and metric from + permutating the feature column. + + Read more in the :ref:`User Guide <permutation_importance>`. + + Parameters + ---------- + estimator : object + An estimator that has already been `fitted` and is compatible with + `scorer`. + + X : ndarray or DataFrame, shape (n_samples, n_features) + Data on which permutation importance will be computed. + + y : array-like or None, shape (n_samples, ) or (n_samples, n_classes) + Targets for supervised or `None` for unsupervised. + + scoring : string, callable or None, default=None + Scorer to use. It can be a single + string (see :ref:`scoring_parameter`) or a callable (see + :ref:`scoring`). If None, the estimator's default scorer is used. + + n_repeats : int, default=5 + Number of times to permute a feature. + + n_jobs : int or None, default=None + The number of jobs to use for the computation. + `None` means 1 unless in a :obj:`joblib.parallel_backend` context. + `-1` means using all processors. See :term:`Glossary <n_jobs>` + for more details. + + random_state : int, RandomState instance, or None, default=None + Pseudo-random number generator to control the permutations of each + feature. See :term:`random_state`. + + Returns + ------- + result : Bunch + Dictionary-like object, with attributes: + + importances_mean : ndarray, shape (n_features, ) + Mean of feature importance over `n_repeats`. + importances_std : ndarray, shape (n_features, ) + Standard deviation over `n_repeats`. + importances : ndarray, shape (n_features, n_repeats) + Raw permutation importance scores. + + References + ---------- + .. [BRE] L. Breiman, "Random Forests", Machine Learning, 45(1), 5-32, + 2001. https://doi.org/10.1023/A:1010933404324 + """ + if hasattr(X, "iloc"): + X = X.copy() # Dataframe + else: + X = check_array(X, force_all_finite='allow-nan', dtype=np.object, + copy=True) + + random_state = check_random_state(random_state) + scorer = check_scoring(estimator, scoring=scoring) + + baseline_score = scorer(estimator, X, y) + scores = np.zeros((X.shape[1], n_repeats)) + + scores = Parallel(n_jobs=n_jobs)(delayed(_calculate_permutation_scores)( + estimator, X, y, col_idx, random_state, n_repeats, scorer + ) for col_idx in range(X.shape[1])) + + importances = baseline_score - np.array(scores) + return Bunch(importances_mean=np.mean(importances, axis=1), + importances_std=np.std(importances, axis=1), + importances=importances)	diff --git a/sklearn/inspection/tests/test_permutation_importance.py b/sklearn/inspection/tests/test_permutation_importance.py new file mode 100644 index 0000000000000..9394202cfce97 --- /dev/null +++ b/sklearn/inspection/tests/test_permutation_importance.py @@ -0,0 +1,154 @@ +import pytest +import numpy as np + +from numpy.testing import assert_allclose + +from sklearn.compose import ColumnTransformer +from sklearn.datasets import load_boston +from sklearn.datasets import load_iris +from sklearn.datasets import make_regression +from sklearn.ensemble import RandomForestRegressor +from sklearn.ensemble import RandomForestClassifier +from sklearn.linear_model import LinearRegression +from sklearn.linear_model import LogisticRegression +from sklearn.impute import SimpleImputer +from sklearn.inspection import permutation_importance +from sklearn.pipeline import make_pipeline +from sklearn.preprocessing import OneHotEncoder +from sklearn.preprocessing import StandardScaler +from sklearn.preprocessing import scale + + +@pytest.mark.parametrize("n_jobs", [1, 2]) +def test_permutation_importance_correlated_feature_regression(n_jobs): + # Make sure that feature highly correlated to the target have a higher + # importance + rng = np.random.RandomState(42) + n_repeats = 5 + + dataset = load_boston() + X, y = dataset.data, dataset.target + y_with_little_noise = ( + y + rng.normal(scale=0.001, size=y.shape[0])).reshape(-1, 1) + + X = np.hstack([X, y_with_little_noise]) + + clf = RandomForestRegressor(n_estimators=10, random_state=42) + clf.fit(X, y) + + result = permutation_importance(clf, X, y, n_repeats=n_repeats, + random_state=rng, n_jobs=n_jobs) + + assert result.importances.shape == (X.shape[1], n_repeats) + + # the correlated feature with y was added as the last column and should + # have the highest importance + assert np.all(result.importances_mean[-1] > + result.importances_mean[:-1]) + + +@pytest.mark.parametrize("n_jobs", [1, 2]) +def test_permutation_importance_correlated_feature_regression_pandas(n_jobs): + pd = pytest.importorskip("pandas") + + # Make sure that feature highly correlated to the target have a higher + # importance + rng = np.random.RandomState(42) + n_repeats = 5 + + dataset = load_iris() + X, y = dataset.data, dataset.target + y_with_little_noise = ( + y + rng.normal(scale=0.001, size=y.shape[0])).reshape(-1, 1) + + # Adds feature correlated with y as the last column + X = pd.DataFrame(X, columns=dataset.feature_names) + X['correlated_feature'] = y_with_little_noise + + clf = RandomForestClassifier(n_estimators=10, random_state=42) + clf.fit(X, y) + + result = permutation_importance(clf, X, y, n_repeats=n_repeats, + random_state=rng, n_jobs=n_jobs) + + assert result.importances.shape == (X.shape[1], n_repeats) + + # the correlated feature with y was added as the last column and should + # have the highest importance + assert np.all(result.importances_mean[-1] > result.importances_mean[:-1]) + + +def test_permutation_importance_mixed_types(): + rng = np.random.RandomState(42) + n_repeats = 4 + + # Last column is correlated with y + X = np.array([[1.0, 2.0, 3.0, np.nan], [2, 1, 2, 1]]).T + y = np.array([0, 1, 0, 1]) + + clf = make_pipeline(SimpleImputer(), LogisticRegression(solver='lbfgs')) + clf.fit(X, y) + result = permutation_importance(clf, X, y, n_repeats=n_repeats, + random_state=rng) + + assert result.importances.shape == (X.shape[1], n_repeats) + + # the correlated feature with y is the last column and should + # have the highest importance + assert np.all(result.importances_mean[-1] > result.importances_mean[:-1]) + + # use another random state + rng = np.random.RandomState(0) + result2 = permutation_importance(clf, X, y, n_repeats=n_repeats, + random_state=rng) + assert result2.importances.shape == (X.shape[1], n_repeats) + + assert not np.allclose(result.importances, result2.importances) + + # the correlated feature with y is the last column and should + # have the highest importance + assert np.all(result2.importances_mean[-1] > result2.importances_mean[:-1]) + + +def test_permutation_importance_mixed_types_pandas(): + pd = pytest.importorskip("pandas") + rng = np.random.RandomState(42) + n_repeats = 5 + + # Last column is correlated with y + X = pd.DataFrame({'col1': [1.0, 2.0, 3.0, np.nan], + 'col2': ['a', 'b', 'a', 'b']}) + y = np.array([0, 1, 0, 1]) + + num_preprocess = make_pipeline(SimpleImputer(), StandardScaler()) + preprocess = ColumnTransformer([ + ('num', num_preprocess, ['col1']), + ('cat', OneHotEncoder(), ['col2']) + ]) + clf = make_pipeline(preprocess, LogisticRegression(solver='lbfgs')) + clf.fit(X, y) + + result = permutation_importance(clf, X, y, n_repeats=n_repeats, + random_state=rng) + + assert result.importances.shape == (X.shape[1], n_repeats) + # the correlated feature with y is the last column and should + # have the highest importance + assert np.all(result.importances_mean[-1] > result.importances_mean[:-1]) + + +def test_permutation_importance_linear_regresssion(): + X, y = make_regression(n_samples=500, n_features=10, random_state=0) + + X = scale(X) + y = scale(y) + + lr = LinearRegression().fit(X, y) + + # this relationship can be computed in closed form + expected_importances = 2 * lr.coef_**2 + results = permutation_importance(lr, X, y, + n_repeats=50, + scoring='neg_mean_squared_error') + assert_allclose(expected_importances, results.importances_mean, + rtol=1e-1, atol=1e-6)	diff --git a/doc/inspection.rst b/doc/inspection.rst index 745539d51bf77..b53aeb436b4cd 100644 --- a/doc/inspection.rst +++ b/doc/inspection.rst @@ -5,6 +5,19 @@ Inspection ---------- +Predictive performance is often the main goal of developing machine learning +models. Yet summarising performance with an evaluation metric is often +insufficient: it assumes that the evaluation metric and test dataset +perfectly reflect the target domain, which is rarely true. In certain domains, +a model needs a certain level of interpretability before it can be deployed. +A model that is exhibiting performance issues needs to be debugged for one to +understand the model's underlying issue. The +:mod:`sklearn.inspection` module provides tools to help understand the +predictions from a model and what affects them. This can be used to +evaluate assumptions and biases of a model, design a better model, or +to diagnose issues with model performance. + .. toctree:: modules/partial_dependence + modules/permutation_importance diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index d9c87362e5a11..30fc3b5102bc6 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -657,6 +657,7 @@ Kernels: :template: function.rst inspection.partial_dependence + inspection.permutation_importance inspection.plot_partial_dependence @@ -1257,7 +1258,6 @@ Model validation pipeline.make_pipeline pipeline.make_union - .. _preprocessing_ref: :mod:`sklearn.preprocessing`: Preprocessing and Normalization diff --git a/doc/modules/permutation_importance.rst b/doc/modules/permutation_importance.rst new file mode 100644 index 0000000000000..d1f850ffeb793 --- /dev/null +++ b/doc/modules/permutation_importance.rst @@ -0,0 +1,69 @@ + +.. _permutation_importance: + +Permutation feature importance +============================== + +.. currentmodule:: sklearn.inspection + +Permutation feature importance is a model inspection technique that can be used +for any `fitted` `estimator` when the data is rectangular. This is especially +useful for non-linear or opaque `estimators`. The permutation feature +importance is defined to be the decrease in a model score when a single feature +value is randomly shuffled [1]_. This procedure breaks the relationship between +the feature and the target, thus the drop in the model score is indicative of +how much the model depends on the feature. This technique benefits from being +model agnostic and can be calculated many times with different permutations of +the feature. + +The :func:`permutation_importance` function calculates the feature importance +of `estimators` for a given dataset. The ``n_repeats`` parameter sets the number +of times a feature is randomly shuffled and returns a sample of feature +importances. Permutation importances can either be computed on the training set +or an held-out testing or validation set. Using a held-out set makes it +possible to highlight which features contribute the most to the generalization +power of the inspected model. Features that are important on the training set +but not on the held-out set might cause the model to overfit. + +Note that features that are deemed non-important for some model with a +low predictive performance could be highly predictive for a model that +generalizes better. The conclusions should always be drawn in the context of +the specific model under inspection and cannot be automatically generalized to +the intrinsic predictive value of the features by them-selves. Therefore it is +always important to evaluate the predictive power of a model using a held-out +set (or better with cross-validation) prior to computing importances. + +Relation to impurity-based importance in trees +---------------------------------------------- + +Tree based models provides a different measure of feature importances based +on the mean decrease in impurity (MDI, the splitting criterion). This gives +importance to features that may not be predictive on unseen data. The +permutation feature importance avoids this issue, since it can be applied to +unseen data. Furthermore, impurity-based feature importance for trees +are strongly biased and favor high cardinality features +(typically numerical features). Permutation-based feature importances do not +exhibit such a bias. Additionally, the permutation feature importance may use +an arbitrary metric on the tree's predictions. These two methods of obtaining +feature importance are explored in: +:ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance.py`. + +Strongly correlated features +---------------------------- + +When two features are correlated and one of the features is permuted, the model +will still have access to the feature through its correlated feature. This will +result in a lower importance for both features, where they might actually be +important. One way to handle this is to cluster features that are correlated +and only keep one feature from each cluster. This use case is explored in: +:ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance_multicollinear.py`. + +.. topic:: Examples: + + * :ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance.py` + * :ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance_multicollinear.py` + +.. topic:: References: + + .. [1] L. Breiman, "Random Forests", Machine Learning, 45(1), 5-32, + 2001. https://doi.org/10.1023/A:1010933404324	[ { "components": [ { "doc": "Set column on X using `col_idx`", "lines": [ 12, 17 ], "name": "_safe_column_setting", "signature": "def _safe_column_setting(X, col_idx, values):", "type": "function" }, { "doc": "Return co...	[ "sklearn/inspection/tests/test_permutation_importance.py::test_permutation_importance_correlated_feature_regression[1]", "sklearn/inspection/tests/test_permutation_importance.py::test_permutation_importance_correlated_feature_regression[2]", "sklearn/inspection/tests/test_permutation_importance.py::test_permuta...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG] Adds Permutation Importance <!-- Thanks for contributing a pull request! Please ensure you have taken a look at the contribution guidelines: https://github.com/scikit-learn/scikit-learn/blob/master/CONTRIBUTING.md#pull-request-checklist --> #### Reference Issues/PRs <!-- Example: Fixes #1234. See also #3456. Please use keywords (e.g., Fixes) to create link to the issues or pull requests you resolved, so that they will automatically be closed when your pull request is merged. See https://github.com/blog/1506-closing-issues-via-pull-requests --> Resolves https://github.com/scikit-learn/scikit-learn/issues/11187 #### What does this implement/fix? Explain your changes. Adds permutation importance to a `model_inspection` module. #### TODO - [x] Initial implementation. - [x] Add example demonstrating the differences between permutation importance and `feature_importances_` when using trees. - [x] Add to user guide. - [x] Support pandas dataframes. <!-- Please be aware that we are a loose team of volunteers so patience is necessary; assistance handling other issues is very welcome. We value all user contributions, no matter how minor they are. If we are slow to review, either the pull request needs some benchmarking, tinkering, convincing, etc. or more likely the reviewers are simply busy. In either case, we ask for your understanding during the review process. For more information, see our FAQ on this topic: http://scikit-learn.org/dev/faq.html#why-is-my-pull-request-not-getting-any-attention. Thanks for contributing! --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/inspection/permutation_importance.py] (definition of _safe_column_setting:) def _safe_column_setting(X, col_idx, values): """Set column on X using `col_idx`""" (definition of _safe_column_indexing:) def _safe_column_indexing(X, col_idx): """Return column from X using `col_idx`""" (definition of _calculate_permutation_scores:) def _calculate_permutation_scores(estimator, X, y, col_idx, random_state, n_repeats, scorer): """Calculate score when `col_idx` is permuted.""" (definition of permutation_importance:) def permutation_importance(estimator, X, y, scoring=None, n_repeats=5, n_jobs=None, random_state=None): """Permutation importance for feature evaluation [BRE]_. The `estimator` is required to be a fitted estimator. `X` can be the data set used to train the estimator or a hold-out set. The permutation importance of a feature is calculated as follows. First, a baseline metric, defined by `scoring`, is evaluated on a (potentially different) dataset defined by the `X`. Next, a feature column from the validation set is permuted and the metric is evaluated again. The permutation importance is defined to be the difference between the baseline metric and metric from permutating the feature column. Read more in the :ref:`User Guide <permutation_importance>`. Parameters ---------- estimator : object An estimator that has already been `fitted` and is compatible with `scorer`. X : ndarray or DataFrame, shape (n_samples, n_features) Data on which permutation importance will be computed. y : array-like or None, shape (n_samples, ) or (n_samples, n_classes) Targets for supervised or `None` for unsupervised. scoring : string, callable or None, default=None Scorer to use. It can be a single string (see :ref:`scoring_parameter`) or a callable (see :ref:`scoring`). If None, the estimator's default scorer is used. n_repeats : int, default=5 Number of times to permute a feature. n_jobs : int or None, default=None The number of jobs to use for the computation. `None` means 1 unless in a :obj:`joblib.parallel_backend` context. `-1` means using all processors. See :term:`Glossary <n_jobs>` for more details. random_state : int, RandomState instance, or None, default=None Pseudo-random number generator to control the permutations of each feature. See :term:`random_state`. Returns ------- result : Bunch Dictionary-like object, with attributes: importances_mean : ndarray, shape (n_features, ) Mean of feature importance over `n_repeats`. importances_std : ndarray, shape (n_features, ) Standard deviation over `n_repeats`. importances : ndarray, shape (n_features, n_repeats) Raw permutation importance scores. References ---------- .. [BRE] L. Breiman, "Random Forests", Machine Learning, 45(1), 5-32, 2001. https://doi.org/10.1023/A:1010933404324""" [end of new definitions in sklearn/inspection/permutation_importance.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		c96e0958da46ebef482a4084cdda3285d5f5ad23
sympy__sympy-15924	15,924	sympy/sympy	1.4	27f2f10b965f912ea38bb189e6b498ec00efdb08	2019-02-04T15:54:08Z	diff --git a/sympy/core/relational.py b/sympy/core/relational.py index 45ff5a96f731..379789e59ca1 100644 --- a/sympy/core/relational.py +++ b/sympy/core/relational.py @@ -122,7 +122,39 @@ def reversed(self): """ ops = {Gt: Lt, Ge: Le, Lt: Gt, Le: Ge} a, b = self.args - return ops.get(self.func, self.func)(b, a, evaluate=False) + return Relational.__new__(ops.get(self.func, self.func), b, a) + + @property + def negated(self): + """Return the negated relationship. + + Examples + ======== + + >>> from sympy import Eq + >>> from sympy.abc import x + >>> Eq(x, 1) + Eq(x, 1) + >>> _.negated + Ne(x, 1) + >>> x < 1 + x < 1 + >>> _.negated + x >= 1 + + Notes + ===== + + This works more or less identical to ``~``/``Not``. The difference is + that ``negated`` returns the relationship even if `evaluate=False`. + Hence, this is useful in code when checking for e.g. negated relations + to exisiting ones as it will not be affected by the `evaluate` flag. + + """ + ops = {Eq: Ne, Ge: Lt, Gt: Le, Le: Gt, Lt: Ge, Ne: Eq} + # If there ever will be new Relational subclasses, the following line will work until it is properly sorted out + # return ops.get(self.func, lambda a, b, evaluate=False: ~(self.func(a, b, evaluate=evaluate)))(self.args, evaluate=False) + return Relational.__new__(ops.get(self.func), self.args) def _eval_evalf(self, prec): return self.func([s._evalf(prec) for s in self.args]) @@ -500,7 +532,7 @@ def __new__(cls, lhs, rhs, options): if evaluate: is_equal = Equality(lhs, rhs) if isinstance(is_equal, BooleanAtom): - return ~is_equal + return is_equal.negated return Relational.__new__(cls, lhs, rhs, options) @@ -524,7 +556,7 @@ def _eval_simplify(self, ratio, measure, rational, inverse): if isinstance(eq, Equality): # send back Ne with the new args return self.func(eq.args) - return ~eq # result of Ne is ~Eq + return eq.negated # result of Ne is the negated Eq Ne = Unequality diff --git a/sympy/functions/elementary/piecewise.py b/sympy/functions/elementary/piecewise.py index 2e74b08975ac..1e0121a22e5a 100644 --- a/sympy/functions/elementary/piecewise.py +++ b/sympy/functions/elementary/piecewise.py @@ -267,12 +267,12 @@ def eval(cls, _args): nonredundant = [] for c in cond.args: if (isinstance(c, Relational) and - (~c).canonical in current_cond): + c.negated.canonical in current_cond): continue nonredundant.append(c) cond = cond.func(nonredundant) elif isinstance(cond, Relational): - if (~cond).canonical in current_cond: + if cond.negated.canonical in current_cond: cond = S.true current_cond.add(cond) diff --git a/sympy/logic/boolalg.py b/sympy/logic/boolalg.py index b0f64ec84156..8bbea2125c94 100644 --- a/sympy/logic/boolalg.py +++ b/sympy/logic/boolalg.py @@ -320,6 +320,10 @@ def __nonzero__(self): def __hash__(self): return hash(True) + @property + def negated(self): + return S.false + def as_set(self): """ Rewrite logic operators and relationals in terms of real sets. @@ -383,6 +387,10 @@ def __nonzero__(self): def __hash__(self): return hash(False) + @property + def negated(self): + return S.true + def as_set(self): """ Rewrite logic operators and relationals in terms of real sets. @@ -542,7 +550,7 @@ def _new_args_filter(cls, args): c = x.canonical if c in rel: continue - nc = (~c).canonical + nc = c.negated.canonical if any(r == nc for r in rel): return [S.false] rel.append(c) @@ -652,7 +660,7 @@ def _new_args_filter(cls, args): c = x.canonical if c in rel: continue - nc = (~c).canonical + nc = c.negated.canonical if any(r == nc for r in rel): return [S.true] rel.append(c) @@ -842,7 +850,7 @@ def __new__(cls, args, kwargs): argset.remove(arg) else: argset.add(arg) - rel = [(r, r.canonical, (~r).canonical) for r in argset if r.is_Relational] + rel = [(r, r.canonical, r.negated.canonical) for r in argset if r.is_Relational] odd = False # is number of complimentary pairs odd? start 0 -> False remove = [] for i, (r, c, nc) in enumerate(rel): @@ -1050,7 +1058,7 @@ def eval(cls, args): elif A.is_Relational and B.is_Relational: if A.canonical == B.canonical: return S.true - if (~A).canonical == B.canonical: + if A.negated.canonical == B.canonical: return B else: return Basic.__new__(cls, args) @@ -1093,7 +1101,7 @@ def __new__(cls, args, **options): rel = [] for r in argset: if isinstance(r, Relational): - rel.append((r, r.canonical, (~r).canonical)) + rel.append((r, r.canonical, r.negated.canonical)) remove = [] for i, (r, c, nc) in enumerate(rel): for j in range(i + 1, len(rel)):	diff --git a/sympy/core/tests/test_relational.py b/sympy/core/tests/test_relational.py index 9c3d6c08d524..6b61c727f689 100644 --- a/sympy/core/tests/test_relational.py +++ b/sympy/core/tests/test_relational.py @@ -1,7 +1,7 @@ from sympy.utilities.pytest import XFAIL, raises from sympy import (S, Symbol, symbols, nan, oo, I, pi, Float, And, Or, Not, Implies, Xor, zoo, sqrt, Rational, simplify, Function, Eq, - log, cos, sin, Add) + log, cos, sin, Add, floor, ceiling) from sympy.core.compatibility import range from sympy.core.relational import (Relational, Equality, Unequality, GreaterThan, LessThan, StrictGreaterThan, @@ -658,17 +658,20 @@ def test_canonical(): @XFAIL -def test_issue_8444(): +def test_issue_8444_nonworkingtests(): x = symbols('x', real=True) assert (x <= oo) == (x >= -oo) == True x = symbols('x') assert x >= floor(x) assert (x < floor(x)) == False - assert Gt(x, floor(x)) == Gt(x, floor(x), evaluate=False) - assert Ge(x, floor(x)) == Ge(x, floor(x), evaluate=False) assert x <= ceiling(x) assert (x > ceiling(x)) == False + +def test_issue_8444_workingtests(): + x = symbols('x') + assert Gt(x, floor(x)) == Gt(x, floor(x), evaluate=False) + assert Ge(x, floor(x)) == Ge(x, floor(x), evaluate=False) assert Lt(x, ceiling(x)) == Lt(x, ceiling(x), evaluate=False) assert Le(x, ceiling(x)) == Le(x, ceiling(x), evaluate=False) i = symbols('i', integer=True) @@ -803,6 +806,21 @@ def test_Equality_rewrite_as_Add(): assert eq.rewrite(Add, evaluate=None).args == (x, x, y, -y) assert eq.rewrite(Add, evaluate=False).args == (x, y, x, -y) + def test_issue_15847(): a = Ne(x(x+y), x2 + xy) assert simplify(a) == False + + +def test_negated_property(): + eq = Eq(x, y) + assert eq.negated == Ne(x, y) + + eq = Ne(x, y) + assert eq.negated == Eq(x, y) + + eq = Ge(x + y, y - x) + assert eq.negated == Lt(x + y, y - x) + + for f in (Eq, Ne, Ge, Gt, Le, Lt): + assert f(x, y).negated.negated == f(x, y) diff --git a/sympy/logic/tests/test_boolalg.py b/sympy/logic/tests/test_boolalg.py index d86e924d1ceb..6c737c3fcb6a 100644 --- a/sympy/logic/tests/test_boolalg.py +++ b/sympy/logic/tests/test_boolalg.py @@ -737,6 +737,11 @@ def test_canonical_atoms(): assert false.canonical == false +def test_negated_atoms(): + assert true.negated == false + assert false.negated == true + + def test_issue_8777(): assert And(x > 2, x < oo).as_set() == Interval(2, oo, left_open=True) assert And(x >= 1, x < oo).as_set() == Interval(1, oo)		[ { "components": [ { "doc": "Return the negated relationship.\n\nExamples\n========\n\n>>> from sympy import Eq\n>>> from sympy.abc import x\n>>> Eq(x, 1)\nEq(x, 1)\n>>> _.negated\nNe(x, 1)\n>>> x < 1\nx < 1\n>>> _.negated\nx >= 1\n\nNotes\n=====\n\nThis works more or less identical to ``~``/``Not`...	[ "test_negated_atoms" ]	[ "test_rel_ne", "test_rel_subs", "test_wrappers", "test_Eq", "test_rel_Infinity", "test_bool", "test_rich_cmp", "test_doit", "test_new_relational", "test_relational_bool_output", "test_relational_logic_symbols", "test_univariate_relational_as_set", "test_Not", "test_evaluate", "test_imagi...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added negated property to Relational and BooleanAtom <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact format, e.g. "Fixes #1234". See https://github.com/blog/1506-closing-issues-via-pull-requests . Please also write a comment on that issue linking back to this pull request once it is open. --> Fixes #15869 #### Brief description of what is fixed or changed I have added a property `negated` to `Relational`s that returns the opposite Relational, so `Eq(x, y).negated` gives `Ne(x, y)`. This has only minor benefits over ~, one is that it ignores evaluate = False, so code that relies on negating a relation, primarily in `logic`, see #15869. The purpose of this code is to compare temporary expressions, so not to actually evaluate the expressions, so from that perspective it should be OK, just as the property `canonical` returns a slightly different expression, independent of evaluate. Hence, it should be used with a bit of care. I also added the property to `BooleanAtom` which makes sense because the result of a `Relational` is a `BooleanAtom`, but doesn't make sense as no other objects in `logic` has that property. From a coding perspective it is only used in a few places (at the moment, only checked quite few cases, could be more). #### Other comments Not sure if there should be a release note. I guess it can be convenient for the user to know about it sometimes. ~~I also believe that it is slightly faster than using Not as there should be more processing steps involved with Not. Not a major factor, but no drawback either.~~ Timeit tests show that this is < 10% slower. Not obvious why. Finally, I split the tests for #8444 as not all of them fails at the moment. Better to have those working is an executed test. Slightly unrelated, but better put it in here as I happened to see it now. Oh, yeah, I was thinking quite long before deciding on `negated`. One may imagine `inverted` or `complemented` as well. And probably a few more options. I know how to change it... #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * core * Relationals now have a property negated, which returns the opposite to the relation, similar to ~. <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/core/relational.py] (definition of Relational.negated:) def negated(self): """Return the negated relationship. Examples ======== >>> from sympy import Eq >>> from sympy.abc import x >>> Eq(x, 1) Eq(x, 1) >>> _.negated Ne(x, 1) >>> x < 1 x < 1 >>> _.negated x >= 1 Notes ===== This works more or less identical to ``~``/``Not``. The difference is that ``negated`` returns the relationship even if `evaluate=False`. Hence, this is useful in code when checking for e.g. negated relations to exisiting ones as it will not be affected by the `evaluate` flag.""" [end of new definitions in sympy/core/relational.py] [start of new definitions in sympy/logic/boolalg.py] (definition of BooleanTrue.negated:) def negated(self): (definition of BooleanFalse.negated:) def negated(self): [end of new definitions in sympy/logic/boolalg.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> Logic: Add `canonical` property to `Not` #### Brief description of what is fixed or changed The `_new_args_filter` for `And` and `Or` calls `(~c).canonical` explicitly, which cause `AttributeError`s because that property is not implemented. To trigger the error, try the following snippet: ``` from sympy import * a, b, c, d = symbols('a b c d') expr = (a > b) & (b > c) with evaluate(False): print(expr.xreplace({b: d})) ``` #### Other comments I'm not 100% that this is the preferred way to fix this, but it highlights the issue and contains one very simple solution. If there is a better way to prevent the given example from triggering an `AttributeError`, please let me know. <!-- BEGIN RELEASE NOTES --> * logic * Added canonical property to Not <!-- END RELEASE NOTES --> ---------- Thanks for your contribution. I'm not sure either, but agree that it seems to make sense. However, can you please add one or a few tests for this in https://github.com/sympy/sympy/blob/master/sympy/logic/tests/test_boolalg.py ? To make sure that the problem is not reintroduced later. The example you provided will be fine. Just add an assert with the correct answer. Plus possibly an explicit in `test_Not()` similar to: https://github.com/sympy/sympy/blob/2b4f967740cc56f864a2271c09215269a0983dd7/sympy/logic/tests/test_boolalg.py#L80 (Which of course raises the question about what the `canonical` property of `Not` actually should be, but clearly it would be good to have it defined, if possible.) @oscargus Thanks for the prompt reply. I've added two small tests, one that basically test the existence of the property `canonical` on `Not` objects and one that tests the behaviour of `Not(A > 1).canonical`. Please note that the second test would actually pass on `master`, since the simplification transforms `Not(A > 1)` into `A <= 1`, unless `evaluate(False)` is used, as in my previous example. However, this should now be caught by the `Not(A).canonical` test. You do need a test, just a modified one that tests the code you added. I'm not sure why you deleted the test completely. Will check back later. @smichr Apologies if I misunderstood you, but I had already added a test `assert Not(A).canonical == Not(A)` to this PR and _that test is still there_. I only added (and now removed) the `Not(e).canonical == Not(e)`, as I wanted to make sure that `Relational`s are covered - but as you rightly pointed out, `Not(A > 1)` will be immediately simplified to `A <= 1`, so that second test is not adding anything new. > if I misunderstood you OK, I see it now. What do you think about returning `self(getattr(self.args[0], 'canonical', self.args[0]))`? @smichr I tried it and got `TypeError: 'Not' object is not callable`. However, returning a new instance with `return Not(getattr(self.args[0], 'canonical', self.args[0]))` seems to work. Does that look alright to you? I left off the func: `return self.func(getattr(self.args[0], 'canonical', self.args[0]))`. This is preferred over returning Not since self may have been derived from Not (if I understand correctly...@asmeurer is the one that has pointed this out to me in the past). @smichr Oh yes, sorry. I forgot that this was the sympy way to re-initialize things (PR updated). Thanks for pointing this out and all your patience. I'm thinking that maybe it is better to add a property/method of `Relational` which simply negates the expression? `inverted`? `negated`? Basically remapping the logic operator to the opposite. A bit like `reversed`, but that actually invert it: https://github.com/sympy/sympy/blob/f472bcc07e8af4080d0e78057dd8beb948d8766f/sympy/core/relational.py#L105-L125 I'm not sure what happens if you apply your code to e.g. `And(x < 1, x >= 1)`, so ``` with evaluate(False): And(x < y, x >= y) ``` I think the purpose of the code is to detect this type of case. Maybe it still works (it evaluates to False without setting evaluate to False)? It seems like the code is maybe just applying a bit of "evaluation" when evaluate is false and that this is taken care of elsewhere when evaluate is true. Out of curiosity, how did you stumble upon the bug? > I'm thinking that maybe it is better I see what you mean: ``` >>> Not(And(x<0,y>1)) ~((y > 1) & (x < 0)) >>> simplify(Not(And(x<0,y>1))) ~((y > 1) & (x < 0)) ``` And rather than adding a canonical property to Not, perhaps it should be added to BooleanFunction to do what was done here on Not. Yes, there may be cases where that can help. When working on the recent PRs, especially #15912, it became quite clear how important it is to be able to express identically meaning expressions on an identical format. So improving #15899 is quite crucial in some cases. If one can extend that to BooleanFunction it would of course be even better, so `Nand(a, b)` and `Or(Not(a), Not(b))` can be identified as the same expressions. Not obvious how to define the requirements there though, but a start is probably to not use Nand, Nor or Nxor in the canonical format, but to apply de Morgan. So shall we commit what is here? Pros: this clarifies the need of a proper canonical for `BooleanFunction`s, the code is there and will solve a few issues Cons: will there be proper canonicals for boolean functions? The alternative as I see it is to add an `inverted` property as discussed above, That will solve all(?) usage in the code today (I've seen this at a few more places with the purpose of identifying the opposite relation so it should just be to replace `(~c).canonical` with `c.inverted.canonical`. At the moment I am more lending towards `inverted` as that does not mix `Boolean` and `Relational`. Although that mix seems quite natural from many aspects. Also, someone must write that property. > Cons: will there be proper canonicals for boolean functions? I think that is the best argument against this. If someone wants canonical relationals, they should make them so individually rather than asking the cotnaining expression to do so since (as you are saying) `canonical` might have meaning for the expression itself. On the otherhand, the invariant could be that `Expr.canonical` returns a canonical expression after making all arguments canonical. But we haven't made a SymPy-wide attribute implementing this idea. So I am in favor of closing this as a WontFix (yet) issue. -------------------- </issues>	e941ad69638189ea42507331e417b88837357dec
pydicom__pydicom-802	802	pydicom/pydicom	1.2	aa42809add6faa389937c846582a3d5196531376	2019-02-02T20:55:26Z	diff --git a/doc/whatsnew/v1.3.0.rst b/doc/whatsnew/v1.3.0.rst index 33b3cb4035..3cc1ac230b 100644 --- a/doc/whatsnew/v1.3.0.rst +++ b/doc/whatsnew/v1.3.0.rst @@ -10,10 +10,15 @@ Changes Use ``dataelem.DataElement.VM`` instead. * ``dataelem.isStringOrStringList`` and ``dataelem.isString`` functions are removed +* ``datadict.add_dict_entry`` and ``datadict.add_dict_entries`` now raise if + trying to add a private tag Enhancements ............ +* Added ``datadict.add_private_dict_entry`` and + ``datadict.add_private_dict_entries`` to add custom private tags + (:issue:`799`) * Added possibility to write into zip file using gzip (:issue:`753`) Fixes diff --git a/pydicom/datadict.py b/pydicom/datadict.py index 434168c3b6..751bac44a8 100644 --- a/pydicom/datadict.py +++ b/pydicom/datadict.py @@ -38,7 +38,7 @@ def add_dict_entry(tag, VR, keyword, description, VM='1', is_retired=''): Notes ---- - Dose not permanently update the dictionary, + Does not permanently update the dictionary, but only during run-time. Will replace an existing entry if the tag already exists in the dictionary. @@ -57,6 +57,11 @@ def add_dict_entry(tag, VR, keyword, description, VM='1', is_retired=''): Usually leave as blank string (default). Set to 'Retired' if is a retired data element. + Raises + ------ + ValueError + If the tag is a private tag. + See Also -------- pydicom.examples.add_dict_entry @@ -67,8 +72,8 @@ def add_dict_entry(tag, VR, keyword, description, VM='1', is_retired=''): Examples -------- >>> from pydicom import Dataset - >>> add_dict_entry(0x10011001, "UL", "TestOne", "Test One") - >>> add_dict_entry(0x10011002, "DS", "TestTwo", "Test Two", VM='3') + >>> add_dict_entry(0x10021001, "UL", "TestOne", "Test One") + >>> add_dict_entry(0x10021002, "DS", "TestTwo", "Test Two", VM='3') >>> ds = Dataset() >>> ds.TestOne = 'test' >>> ds.TestTwo = ['1', '2', '3'] @@ -79,7 +84,7 @@ def add_dict_entry(tag, VR, keyword, description, VM='1', is_retired=''): def add_dict_entries(new_entries_dict): - """Update pydicom's DICOM dictionary with new entries. + """Update pydicom's DICOM dictionary with new non-private entries. Parameters ---------- @@ -88,6 +93,11 @@ def add_dict_entries(new_entries_dict): {tag: (VR, VM, description, is_retired, keyword),...} where parameters are as described in add_dict_entry + Raises + ------ + ValueError + If one of the entries is a private tag. + See Also -------- add_dict_entry @@ -97,19 +107,24 @@ def add_dict_entries(new_entries_dict): -------- >>> from pydicom import Dataset >>> new_dict_items = { - ... 0x10011001: ('UL', '1', "Test One", '', 'TestOne'), - ... 0x10011002: ('DS', '3', "Test Two", '', 'TestTwo'), + ... 0x10021001: ('UL', '1', "Test One", '', 'TestOne'), + ... 0x10021002: ('DS', '3', "Test Two", '', 'TestTwo'), ... } >>> add_dict_entries(new_dict_items) >>> ds = Dataset() >>> ds.TestOne = 'test' >>> ds.TestTwo = ['1', '2', '3'] - >>> add_dict_entry(0x10011001, "UL", "TestOne", "Test One") + >>> add_dict_entry(0x10021001, "UL", "TestOne", "Test One") >>> ds = Dataset() >>> ds.TestOne = 'test' """ + if any([BaseTag(tag).is_private for tag in new_entries_dict]): + raise ValueError( + 'Private tags cannot be added using "add_dict_entries" - ' + 'use "add_private_dict_entries" instead') + # Update the dictionary itself DicomDictionary.update(new_entries_dict) @@ -119,6 +134,84 @@ def add_dict_entries(new_entries_dict): keyword_dict.update(new_names_dict) +def add_private_dict_entry(private_creator, tag, VR, description, VM='1'): + """Update pydicom's private DICOM tag dictionary with a new entry. + + Notes + ---- + Behaves like `add_dict_entry`, only for a private tag entry. + + Parameters + ---------- + private_creator : str + The private creator for the new entry. + tag : int + The tag number for the new dictionary entry. Note that the + 2 high bytes of the element part of the tag are ignored. + VR : str + DICOM value representation + description : str + The descriptive name used in printing the entry. + VM : str, optional + DICOM value multiplicity. If not specified, then '1' is used. + + Raises + ------ + ValueError + If the tag is a non-private tag. + + See Also + -------- + add_private_dict_entries + Update multiple values at once. + """ + new_dict_val = (VR, VM, description) + add_private_dict_entries(private_creator, {tag: new_dict_val}) + + +def add_private_dict_entries(private_creator, new_entries_dict): + """Update pydicom's private DICOM tag dictionary with new entries. + + Parameters + ---------- + private_creator: str + The private creator for all entries in new_entries_dict + new_entries_dict : dict + Dictionary of form: + {tag: (VR, VM, description),...} + where parameters are as described in add_private_dict_entry + + Raises + ------ + ValueError + If one of the entries is a non-private tag. + + See Also + -------- + add_private_dict_entry + Function to add a single entry to the private tag dictionary. + + Examples + -------- + >>> new_dict_items = { + ... 0x00410001: ('UL', '1', "Test One"), + ... 0x00410002: ('DS', '3', "Test Two", '3'), + ... } + >>> add_private_dict_entries("ACME LTD 1.2", new_dict_items) + >>> add_private_dict_entry("ACME LTD 1.3", 0x00410001, "US", "Test Three") + """ + + if not all([BaseTag(tag).is_private for tag in new_entries_dict]): + raise ValueError( + 'Non-private tags cannot be added using "add_private_dict_entries"' + ' - use "add_dict_entries" instead') + + new_entries = {'{:04x}xx{:02x}'.format(tag >> 16, tag & 0xff): value + for tag, value in new_entries_dict.items()} + private_dictionaries.setdefault( + private_creator, {}).update(new_entries) + + def get_entry(tag): """Return the tuple (VR, VM, name, is_retired, keyword) from the DICOM dictionary	diff --git a/pydicom/tests/test_dictionary.py b/pydicom/tests/test_dictionary.py index bbcec875c6..f575aaa278 100644 --- a/pydicom/tests/test_dictionary.py +++ b/pydicom/tests/test_dictionary.py @@ -1,81 +1,137 @@ # Copyright 2008-2018 pydicom authors. See LICENSE file for details. """Test for datadict.py""" -import unittest +import pytest + +from pydicom import DataElement from pydicom.dataset import Dataset from pydicom.datadict import (keyword_for_tag, dictionary_description, dictionary_has_tag, repeater_has_tag, repeater_has_keyword, get_private_entry, dictionary_VM, private_dictionary_VR, - private_dictionary_VM) + private_dictionary_VM, add_private_dict_entries, + add_private_dict_entry) from pydicom.datadict import add_dict_entry, add_dict_entries -class DictTests(unittest.TestCase): - def testTagNotFound(self): +class TestDict(object): + def test_tag_not_found(self): """dicom_dictionary: CleanName returns blank string for unknown tag""" - self.assertTrue(keyword_for_tag(0x99991111) == "") + assert '' == keyword_for_tag(0x99991111) - def testRepeaters(self): + def test_repeaters(self): """dicom_dictionary: Tags with "x" return correct dict info........""" - self.assertEqual(dictionary_description(0x280400), 'Transform Label') - self.assertEqual(dictionary_description(0x280410), - 'Rows For Nth Order Coefficients') + assert 'Transform Label' == dictionary_description(0x280400) + assert ('Rows For Nth Order Coefficients' == + dictionary_description(0x280410)) def test_dict_has_tag(self): """Test dictionary_has_tag""" - self.assertTrue(dictionary_has_tag(0x00100010)) - self.assertFalse(dictionary_has_tag(0x11110010)) + assert dictionary_has_tag(0x00100010) + assert not dictionary_has_tag(0x11110010) def test_repeater_has_tag(self): """Test repeater_has_tag""" - self.assertTrue(repeater_has_tag(0x60000010)) - self.assertTrue(repeater_has_tag(0x60020010)) - self.assertFalse(repeater_has_tag(0x00100010)) + assert repeater_has_tag(0x60000010) + assert repeater_has_tag(0x60020010) + assert not repeater_has_tag(0x00100010) def test_repeater_has_keyword(self): """Test repeater_has_keyword""" - self.assertTrue(repeater_has_keyword('OverlayData')) - self.assertFalse(repeater_has_keyword('PixelData')) + assert repeater_has_keyword('OverlayData') + assert not repeater_has_keyword('PixelData') def test_get_private_entry(self): """Test get_private_entry""" # existing entry entry = get_private_entry((0x0903, 0x0011), 'GEIIS PACS') - self.assertEqual('US', entry[0]) # VR - self.assertEqual('1', entry[1]) # VM - self.assertEqual('Significant Flag', entry[2]) # name - self.assertFalse(entry[3]) # is retired + assert 'US' == entry[0] # VR + assert '1' == entry[1] # VM + assert 'Significant Flag' == entry[2] # name + assert not entry[3] # is retired # existing entry in another slot entry = get_private_entry((0x0903, 0x1011), 'GEIIS PACS') - self.assertEqual('Significant Flag', entry[2]) # name + assert 'Significant Flag' == entry[2] # name # non-existing entry - self.assertRaises(KeyError, get_private_entry, - (0x0903, 0x0011), 'Nonexisting') - self.assertRaises(KeyError, get_private_entry, - (0x0903, 0x0091), 'GEIIS PACS') + with pytest.raises(KeyError): + get_private_entry((0x0903, 0x0011), 'Nonexisting') + with pytest.raises(KeyError): + get_private_entry((0x0903, 0x0091), 'GEIIS PACS') - def testAddEntry(self): + def test_add_entry(self): """dicom_dictionary: Can add and use a single dictionary entry""" - add_dict_entry(0x10011001, "UL", "TestOne", "Test One") - add_dict_entry(0x10011002, "DS", "TestTwo", "Test Two", VM='3') + add_dict_entry(0x10021001, "UL", "TestOne", "Test One") + add_dict_entry(0x10021002, "DS", "TestTwo", "Test Two", VM='3') ds = Dataset() ds.TestOne = 'test' ds.TestTwo = ['1', '2', '3'] - def testAddEntries(self): + def test_add_entry_raises_for_private_tag(self): + with pytest.raises(ValueError, + match='Private tags cannot be ' + 'added using "add_dict_entries"'): + add_dict_entry(0x10011101, 'DS', 'Test One', 'Test One') + + def test_add_entries(self): """dicom_dictionary: add and use a dict of new dictionary entries""" new_dict_items = { - 0x10011001: ('UL', '1', "Test One", '', 'TestOne'), - 0x10011002: ('DS', '3', "Test Two", '', 'TestTwo'), - } + 0x10021001: ('UL', '1', "Test One", '', 'TestOne'), + 0x10021002: ('DS', '3', "Test Two", '', 'TestTwo'), + } add_dict_entries(new_dict_items) ds = Dataset() ds.TestOne = 'test' ds.TestTwo = ['1', '2', '3'] + def test_add_entries_raises_for_private_tags(self): + new_dict_items = { + 0x10021001: ('UL', '1', 'Test One', '', 'TestOne'), + 0x10011002: ('DS', '3', 'Test Two', '', 'TestTwo'), + } + with pytest.raises(ValueError, match='Private tags cannot be added ' + 'using "add_dict_entries"'): + add_dict_entries(new_dict_items) + + def test_add_private_entry(self): + add_private_dict_entry('ACME 3.1', 0x10011101, 'DS', 'Test One', '3') + entry = get_private_entry((0x1001, 0x0001), 'ACME 3.1') + assert 'DS' == entry[0] # VR + assert '3' == entry[1] # VM + assert 'Test One' == entry[2] # description + + def test_add_private_entry_raises_for_non_private_tag(self): + with pytest.raises(ValueError, + match='Non-private tags cannot be ' + 'added using "add_private_dict_entries"'): + add_private_dict_entry('ACME 3.1', 0x10021101, 'DS', 'Test One') + + def test_add_private_entries(self): + """dicom_dictionary: add and use a dict of new dictionary entries""" + new_dict_items = { + 0x10011001: ('SH', '1', "Test One",), + 0x10011002: ('DS', '3', "Test Two", '', 'TestTwo'), + } + add_private_dict_entries('ACME 3.1', new_dict_items) + ds = Dataset() + ds[0x10010010] = DataElement(0x10010010, 'LO', 'ACME 3.1') + ds[0x10011001] = DataElement(0x10011001, 'SH', 'Test') + ds[0x10011002] = DataElement(0x10011002, 'DS', '1\\2\\3') + + assert 'Test' == ds[0x10011001].value + assert [1, 2, 3] == ds[0x10011002].value + + def test_add_private_entries_raises_for_non_private_tags(self): + new_dict_items = { + 0x10021001: ('UL', '1', 'Test One', '', 'TestOne'), + 0x10011002: ('DS', '3', 'Test Two', '', 'TestTwo'), + } + with pytest.raises(ValueError, + match='Non-private tags cannot be ' + 'added using "add_private_dict_entries"'): + add_private_dict_entries('ACME 3.1', new_dict_items) + def test_dictionary_VM(self): """Test dictionary_VM""" assert dictionary_VM(0x00000000) == '1' @@ -93,7 +149,3 @@ def test_private_dict_VR(self): def test_private_dict_VM(self): """Test private_dictionary_VM""" assert private_dictionary_VM(0x00090000, 'ACUSON') == '1' - - -if __name__ == "__main__": - unittest.main()	diff --git a/doc/whatsnew/v1.3.0.rst b/doc/whatsnew/v1.3.0.rst index 33b3cb4035..3cc1ac230b 100644 --- a/doc/whatsnew/v1.3.0.rst +++ b/doc/whatsnew/v1.3.0.rst @@ -10,10 +10,15 @@ Changes Use ``dataelem.DataElement.VM`` instead. * ``dataelem.isStringOrStringList`` and ``dataelem.isString`` functions are removed +* ``datadict.add_dict_entry`` and ``datadict.add_dict_entries`` now raise if + trying to add a private tag Enhancements ............ +* Added ``datadict.add_private_dict_entry`` and + ``datadict.add_private_dict_entries`` to add custom private tags + (:issue:`799`) * Added possibility to write into zip file using gzip (:issue:`753`) Fixes	[ { "components": [ { "doc": "Update pydicom's private DICOM tag dictionary with a new entry.\n\nNotes\n----\nBehaves like `add_dict_entry`, only for a private tag entry.\n\nParameters\n----------\nprivate_creator : str\n The private creator for the new entry.\ntag : int\n The tag number for t...	[ "pydicom/tests/test_dictionary.py::TestDict::test_tag_not_found", "pydicom/tests/test_dictionary.py::TestDict::test_repeaters", "pydicom/tests/test_dictionary.py::TestDict::test_dict_has_tag", "pydicom/tests/test_dictionary.py::TestDict::test_repeater_has_tag", "pydicom/tests/test_dictionary.py::TestDict::t...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG] Added possibility to add tags to the private dictionary - datadict.add_dict_entry and datadict.add_dict_entries now raise if trying to add a private tag - the new methods datadict.add_private_dict_entry/add_private_dict_entries likely raise if trying to add non-private entries - see #799 <!-- Thanks for contributing a pull request! Please ensure you have taken a look at the contribution guidelines: https://github.com/pydicom/pydicom/blob/master/CONTRIBUTING.md#contributing-pull-requests --> #### Reference Issue <!-- Example: Fixes #1234 --> #### What does this implement/fix? Explain your changes. <!-- Please summarize the key points of the reference issue, problem or contribution to facilitate reviewing task. Of course reviewers can always refer to the original issue but facilitating the reviewing process is much appreciated. --> #### Any other comments? <!-- --> <!-- Please be aware that we are a loose team of volunteers so patience is necessary; assistance handling other issues is very welcome. We value all user contributions, no matter how minor they are. If we are slow to review, either the pull request needs some benchmarking, tinkering, convincing, etc. or more likely the reviewers are simply busy. In either case, we ask for your understanding during the review process. Thanks for contributing! --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pydicom/datadict.py] (definition of add_private_dict_entry:) def add_private_dict_entry(private_creator, tag, VR, description, VM='1'): """Update pydicom's private DICOM tag dictionary with a new entry. Notes ---- Behaves like `add_dict_entry`, only for a private tag entry. Parameters ---------- private_creator : str The private creator for the new entry. tag : int The tag number for the new dictionary entry. Note that the 2 high bytes of the element part of the tag are ignored. VR : str DICOM value representation description : str The descriptive name used in printing the entry. VM : str, optional DICOM value multiplicity. If not specified, then '1' is used. Raises ------ ValueError If the tag is a non-private tag. See Also -------- add_private_dict_entries Update multiple values at once.""" (definition of add_private_dict_entries:) def add_private_dict_entries(private_creator, new_entries_dict): """Update pydicom's private DICOM tag dictionary with new entries. Parameters ---------- private_creator: str The private creator for all entries in new_entries_dict new_entries_dict : dict Dictionary of form: {tag: (VR, VM, description),...} where parameters are as described in add_private_dict_entry Raises ------ ValueError If one of the entries is a non-private tag. See Also -------- add_private_dict_entry Function to add a single entry to the private tag dictionary. Examples -------- >>> new_dict_items = { ... 0x00410001: ('UL', '1', "Test One"), ... 0x00410002: ('DS', '3', "Test Two", '3'), ... } >>> add_private_dict_entries("ACME LTD 1.2", new_dict_items) >>> add_private_dict_entry("ACME LTD 1.3", 0x00410001, "US", "Test Three")""" [end of new definitions in pydicom/datadict.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		3551f5b5a5f8d4de3ed92e5e479ac8c74a8c893a
sympy__sympy-15825	15,825	sympy/sympy	1.4	de3c43c77670a1430756e66d2d70975ee9c6affa	2019-01-22T15:38:51Z	diff --git a/sympy/crypto/__init__.py b/sympy/crypto/__init__.py index 757b33ab73b2..58ffb98e59e0 100644 --- a/sympy/crypto/__init__.py +++ b/sympy/crypto/__init__.py @@ -11,4 +11,4 @@ encipher_elgamal, dh_private_key, dh_public_key, dh_shared_key, padded_key, encipher_bifid, decipher_bifid, bifid_square, bifid5, bifid6, bifid10, decipher_gm, encipher_gm, gm_public_key, - gm_private_key) + gm_private_key, bg_private_key, bg_public_key, encipher_bg, decipher_bg) diff --git a/sympy/crypto/crypto.py b/sympy/crypto/crypto.py index a68dc35bdc71..a96957b4f046 100644 --- a/sympy/crypto/crypto.py +++ b/sympy/crypto/crypto.py @@ -28,7 +28,7 @@ from sympy.polys.polytools import gcd, Poly from sympy.utilities.misc import filldedent, translate from sympy.utilities.iterables import uniq -from sympy.utilities.randtest import _randrange +from sympy.utilities.randtest import _randrange, _randint def AZ(s=None): @@ -2246,3 +2246,172 @@ def decipher_gm(message, key): m <<= 1 m += not b return m + +################ Blum–Goldwasser cryptosystem ######################### + +def bg_private_key(p, q): + """ + Check if p and q can be used as private keys for + the Blum–Goldwasser cryptosystem. + + The three necessary checks for p and q to pass + so that they can be used as private keys: + + 1. p and q must both be prime + 2. p and q must be distinct + 3. p and q must be congruent to 3 mod 4 + + Parameters + ========== + + p, q : the keys to be checked + + Returns + ======= + + p, q : input values + + Raises + ====== + + ValueError : if p and q do not pass the above conditions + + """ + + if not isprime(p) or not isprime(q): + raise ValueError("the two arguments must be prime, " + "got %i and %i" %(p, q)) + elif p == q: + raise ValueError("the two arguments must be distinct, " + "got two copies of %i. " %p) + elif (p - 3) % 4 != 0 or (q - 3) % 4 != 0: + raise ValueError("the two arguments must be congruent to 3 mod 4, " + "got %i and %i" %(p, q)) + return p, q + +def bg_public_key(p, q): + """ + Calculates public keys from private keys. + + The function first checks the validity of + private keys passed as arguments and + then returns their product. + + Parameters + ========== + + p, q : the private keys + + Returns + ======= + + N : the public key + """ + p, q = bg_private_key(p, q) + N = p * q + return N + +def encipher_bg(i, key, seed=None): + """ + Encrypts the message using public key and seed. + + ALGORITHM: + 1. Encodes i as a string of L bits, m. + 2. Select a random element r, where 1 < r < key, and computes + x = r^2 mod key. + 3. Use BBS pseudo-random number generator to generate L random bits, b, + using the initial seed as x. + 4. Encrypted message, c_i = m_i XOR b_i, 1 <= i <= L. + 5. x_L = x^(2^L) mod key. + 6. Return (c, x_L) + + Parameters + ========== + + i : message, a non-negative integer + key : the public key + + Returns + ======= + + (encrypted_message, x_L) : Tuple + + Raises + ====== + + ValueError : if i is negative + """ + + if i < 0: + raise ValueError( + "message must be a non-negative " + "integer: got %d instead" % i) + + enc_msg = [] + while i > 0: + enc_msg.append(i % 2) + i //= 2 + enc_msg.reverse() + L = len(enc_msg) + + r = _randint(seed)(2, key - 1) + x = r2 % key + x_L = pow(int(x), int(2L), int(key)) + + rand_bits = [] + for k in range(L): + rand_bits.append(x % 2) + x = x*2 % key + + encrypt_msg = [m ^ b for (m, b) in zip(enc_msg, rand_bits)] + + return (encrypt_msg, x_L) + +def decipher_bg(message, key): + """ + Decrypts the message using private keys. + + ALGORITHM: + 1. Let, c be the encrypted message, y the second number received, + and p and q be the private keys. + 2. Compute, r_p = y^((p+1)/4 ^ L) mod p and + r_q = y^((q+1)/4 ^ L) mod q. + 3. Compute x_0 = (q(q^-1 mod p)r_p + p(p^-1 mod q)r_q) mod N. + 4. From, recompute the bits using the BBS generator, as in the + encryption algorithm. + 5. Compute original message by XORing c and b. + + Parameters + ========== + + message : Tuple of encrypted message and a non-negative integer. + key : Tuple of private keys + + Returns + ======= + + orig_msg : The original message + """ + + p, q = key + encrypt_msg, y = message + public_key = p q + L = len(encrypt_msg) + p_t = ((p + 1)/4)L + q_t = ((q + 1)/4)L + r_p = pow(int(y), int(p_t), int(p)) + r_q = pow(int(y), int(q_t), int(q)) + + x = (q * mod_inverse(q, p) * r_p + p * mod_inverse(p, q) * r_q) % public_key + + orig_bits = [] + for k in range(L): + orig_bits.append(x % 2) + x = x*2 % public_key + + orig_msg = 0 + for (m, b) in zip(encrypt_msg, orig_bits): + orig_msg = orig_msg 2 + orig_msg += (m ^ b) + + return orig_msg	diff --git a/sympy/crypto/tests/test_crypto.py b/sympy/crypto/tests/test_crypto.py index 80a0946f3670..24fb8a101d1e 100644 --- a/sympy/crypto/tests/test_crypto.py +++ b/sympy/crypto/tests/test_crypto.py @@ -13,7 +13,8 @@ encipher_elgamal, decipher_elgamal, dh_private_key, dh_public_key, dh_shared_key, decipher_shift, decipher_affine, encipher_bifid, decipher_bifid, bifid_square, padded_key, uniq, decipher_gm, - encipher_gm, gm_public_key, gm_private_key) + encipher_gm, gm_public_key, gm_private_key, encipher_bg, decipher_bg, + bg_private_key, bg_public_key) from sympy.matrices import Matrix from sympy.ntheory import isprime, is_primitive_root from sympy.polys.domains import FF @@ -335,3 +336,32 @@ def test_gm_public_key(): assert 323 == gm_public_key(17, 19)[1] assert 15 == gm_public_key(3, 5)[1] raises(ValueError, lambda: gm_public_key(15, 19)) + +def test_encipher_decipher_bg(): + ps = [67, 7, 71, 103, 11, 43, 107, 47, + 79, 19, 83, 23, 59, 127, 31] + qs = qs = [7, 71, 103, 11, 43, 107, 47, + 79, 19, 83, 23, 59, 127, 31, 67] + messages = [ + 0, 328, 343, 148, 1280, 758, 383, + 724, 603, 516, 766, 618, 186, + ] + + for p, q in zip(ps, qs): + pri = bg_private_key(p, q) + for msg in messages: + pub = bg_public_key(p, q) + enc = encipher_bg(msg, pub) + dec = decipher_bg(enc, pri) + assert dec == msg + +def test_bg_private_key(): + raises(ValueError, lambda: bg_private_key(8, 16)) + raises(ValueError, lambda: bg_private_key(8, 8)) + raises(ValueError, lambda: bg_private_key(13, 17)) + assert 23, 31 == bg_private_key(23, 31) + +def test_bg_public_key(): + assert 5293 == bg_public_key(67, 79) + assert 713 == bg_public_key(23, 31) + raises(ValueError, lambda: bg_private_key(13, 17))		[ { "components": [ { "doc": "Check if p and q can be used as private keys for\nthe Blum–Goldwasser cryptosystem.\n\nThe three necessary checks for p and q to pass\nso that they can be used as private keys:\n\n 1. p and q must both be prime\n 2. p and q must be distinct\n 3. p and q must be...	[ "test_cycle_list", "test_encipher_shift", "test_encipher_affine", "test_encipher_substitution", "test_check_and_join", "test_encipher_vigenere", "test_decipher_vigenere", "test_encipher_hill", "test_decipher_hill", "test_encipher_bifid5", "test_bifid5_square", "test_decipher_bifid5", "test_e...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added Blum Goldwasser cryptosystem <!-- Your title above should be a short description of what was changed. Do not include the issue number in the title. --> #### References to other Issues or PRs https://en.wikipedia.org/wiki/Blum%E2%80%93Goldwasser_cryptosystem #### Brief description of what is fixed or changed bg_private_key, bg_public_key, encipher_bg have been added to sympy.crypto.crypto. These methods follow Blum–Goldwasser cryptosystem. #### Other comments Documentation and tests will be added soon #### Release Notes <!-- Write the release notes for this release below. See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information on how to write release notes. The bot will check your release notes automatically to see if they are formatted correctly. --> <!-- BEGIN RELEASE NOTES --> * crypto * Added Blum Goldwasser cryptosystem <!-- END RELEASE NOTES --> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/crypto/crypto.py] (definition of bg_private_key:) def bg_private_key(p, q): """Check if p and q can be used as private keys for the Blum–Goldwasser cryptosystem. The three necessary checks for p and q to pass so that they can be used as private keys: 1. p and q must both be prime 2. p and q must be distinct 3. p and q must be congruent to 3 mod 4 Parameters ========== p, q : the keys to be checked Returns ======= p, q : input values Raises ====== ValueError : if p and q do not pass the above conditions""" (definition of bg_public_key:) def bg_public_key(p, q): """Calculates public keys from private keys. The function first checks the validity of private keys passed as arguments and then returns their product. Parameters ========== p, q : the private keys Returns ======= N : the public key""" (definition of encipher_bg:) def encipher_bg(i, key, seed=None): """Encrypts the message using public key and seed. ALGORITHM: 1. Encodes i as a string of L bits, m. 2. Select a random element r, where 1 < r < key, and computes x = r^2 mod key. 3. Use BBS pseudo-random number generator to generate L random bits, b, using the initial seed as x. 4. Encrypted message, c_i = m_i XOR b_i, 1 <= i <= L. 5. x_L = x^(2^L) mod key. 6. Return (c, x_L) Parameters ========== i : message, a non-negative integer key : the public key Returns ======= (encrypted_message, x_L) : Tuple Raises ====== ValueError : if i is negative""" (definition of decipher_bg:) def decipher_bg(message, key): """Decrypts the message using private keys. ALGORITHM: 1. Let, c be the encrypted message, y the second number received, and p and q be the private keys. 2. Compute, r_p = y^((p+1)/4 ^ L) mod p and r_q = y^((q+1)/4 ^ L) mod q. 3. Compute x_0 = (q(q^-1 mod p)r_p + p(p^-1 mod q)r_q) mod N. 4. From, recompute the bits using the BBS generator, as in the encryption algorithm. 5. Compute original message by XORing c and b. Parameters ========== message : Tuple of encrypted message and a non-negative integer. key : Tuple of private keys Returns ======= orig_msg : The original message""" [end of new definitions in sympy/crypto/crypto.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		e941ad69638189ea42507331e417b88837357dec
scikit-learn__scikit-learn-13003	13,003	scikit-learn/scikit-learn	0.24	57bd85ed6a613028c2abb5e27dcf30263f0daa4b	2019-01-17T12:26:31Z	diff --git a/benchmarks/bench_plot_polynomial_kernel_approximation.py b/benchmarks/bench_plot_polynomial_kernel_approximation.py new file mode 100644 index 0000000000000..2b7556f37320e --- /dev/null +++ b/benchmarks/bench_plot_polynomial_kernel_approximation.py @@ -0,0 +1,156 @@ +""" +======================================================================== +Benchmark for explicit feature map approximation of polynomial kernels +======================================================================== + +An example illustrating the approximation of the feature map +of an Homogeneous Polynomial kernel. + +.. currentmodule:: sklearn.kernel_approximation + +It shows how to use :class:`PolynomialCountSketch` and :class:`Nystroem` to +approximate the feature map of a polynomial kernel for +classification with an SVM on the digits dataset. Results using a linear +SVM in the original space, a linear SVM using the approximate mappings +and a kernelized SVM are compared. + +The first plot shows the classification accuracy of Nystroem [2] and +PolynomialCountSketch [1] as the output dimension (n_components) grows. +It also shows the accuracy of a linear SVM and a polynomial kernel SVM +on the same data. + +The second plot explores the scalability of PolynomialCountSketch +and Nystroem. For a sufficiently large output dimension, +PolynomialCountSketch should be faster as it is O(n(d+klog k)) +while Nystroem is O(n(dk+k^2)). In addition, Nystroem requires +a time-consuming training phase, while training is almost immediate +for PolynomialCountSketch, whose training phase boils down to +initializing some random variables (because is data-independent). + +[1] Pham, N., & Pagh, R. (2013, August). Fast and scalable polynomial +kernels via explicit feature maps. In Proceedings of the 19th ACM SIGKDD +international conference on Knowledge discovery and data mining (pp. 239-247) +(http://chbrown.github.io/kdd-2013-usb/kdd/p239.pdf) + +[2] Charikar, M., Chen, K., & Farach-Colton, M. (2002, July). Finding frequent +items in data streams. In International Colloquium on Automata, Languages, and +Programming (pp. 693-703). Springer, Berlin, Heidelberg. +(http://www.vldb.org/pvldb/1/1454225.pdf) + +""" +# Author: Daniel Lopez-Sanchez <lope@usal.es> +# License: BSD 3 clause + +# Load data manipulation functions +from sklearn.datasets import load_digits +from sklearn.model_selection import train_test_split + +# Some common libraries +import matplotlib.pyplot as plt +import numpy as np + +# Will use this for timing results +from time import time + +# Import SVM classifiers and feature map approximation algorithms +from sklearn.svm import LinearSVC, SVC +from sklearn.kernel_approximation import Nystroem, PolynomialCountSketch +from sklearn.pipeline import Pipeline + +# Split data in train and test sets +X, y = load_digits()["data"], load_digits()["target"] +X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7) + +# Set the range of n_components for our experiments +out_dims = range(20, 400, 20) + +# Evaluate Linear SVM +lsvm = LinearSVC().fit(X_train, y_train) +lsvm_score = 100lsvm.score(X_test, y_test) + +# Evaluate kernelized SVM +ksvm = SVC(kernel="poly", degree=2, gamma=1.).fit(X_train, y_train) +ksvm_score = 100ksvm.score(X_test, y_test) + +# Evaluate PolynomialCountSketch + LinearSVM +ps_svm_scores = [] +n_runs = 5 + +# To compensate for the stochasticity of the method, we make n_tets runs +for k in out_dims: + score_avg = 0 + for _ in range(n_runs): + ps_svm = Pipeline([("PS", PolynomialCountSketch(degree=2, + n_components=k)), + ("SVM", LinearSVC())]) + score_avg += ps_svm.fit(X_train, y_train).score(X_test, y_test) + ps_svm_scores.append(100score_avg/n_runs) + +# Evaluate Nystroem + LinearSVM +ny_svm_scores = [] +n_runs = 5 + +for k in out_dims: + score_avg = 0 + for _ in range(n_runs): + ny_svm = Pipeline([("NY", Nystroem(kernel="poly", gamma=1., degree=2, + coef0=0, n_components=k)), + ("SVM", LinearSVC())]) + score_avg += ny_svm.fit(X_train, y_train).score(X_test, y_test) + ny_svm_scores.append(100score_avg/n_runs) + +# Show results +fig, ax = plt.subplots(figsize=(6, 4)) +ax.set_title("Accuracy results") +ax.plot(out_dims, ps_svm_scores, label="PolynomialCountSketch + linear SVM", + c="orange") +ax.plot(out_dims, ny_svm_scores, label="Nystroem + linear SVM", + c="blue") +ax.plot([out_dims[0], out_dims[-1]], [lsvm_score, lsvm_score], + label="Linear SVM", c="black", dashes=[2, 2]) +ax.plot([out_dims[0], out_dims[-1]], [ksvm_score, ksvm_score], + label="Poly-kernel SVM", c="red", dashes=[2, 2]) +ax.legend() +ax.set_xlabel("N_components for PolynomialCountSketch and Nystroem") +ax.set_ylabel("Accuracy (%)") +ax.set_xlim([out_dims[0], out_dims[-1]]) +fig.tight_layout() + +# Now lets evaluate the scalability of PolynomialCountSketch vs Nystroem +# First we generate some fake data with a lot of samples + +fakeData = np.random.randn(10000, 100) +fakeDataY = np.random.randint(0, high=10, size=(10000)) + +out_dims = range(500, 6000, 500) + +# Evaluate scalability of PolynomialCountSketch as n_components grows +ps_svm_times = [] +for k in out_dims: + ps = PolynomialCountSketch(degree=2, n_components=k) + + start = time() + ps.fit_transform(fakeData, None) + ps_svm_times.append(time() - start) + +# Evaluate scalability of Nystroem as n_components grows +# This can take a while due to the inefficient training phase +ny_svm_times = [] +for k in out_dims: + ny = Nystroem(kernel="poly", gamma=1., degree=2, coef0=0, n_components=k) + + start = time() + ny.fit_transform(fakeData, None) + ny_svm_times.append(time() - start) + +# Show results +fig, ax = plt.subplots(figsize=(6, 4)) +ax.set_title("Scalability results") +ax.plot(out_dims, ps_svm_times, label="PolynomialCountSketch", c="orange") +ax.plot(out_dims, ny_svm_times, label="Nystroem", c="blue") +ax.legend() +ax.set_xlabel("N_components for PolynomialCountSketch and Nystroem") +ax.set_ylabel("fit_transform time \n(s/10.000 samples)") +ax.set_xlim([out_dims[0], out_dims[-1]]) +fig.tight_layout() +plt.show() diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 2e54d000a13aa..70a5174629f37 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -706,6 +706,7 @@ Plotting kernel_approximation.AdditiveChi2Sampler kernel_approximation.Nystroem + kernel_approximation.PolynomialCountSketch kernel_approximation.RBFSampler kernel_approximation.SkewedChi2Sampler diff --git a/doc/modules/kernel_approximation.rst b/doc/modules/kernel_approximation.rst index fb3843c6bc045..4f5ee46a42057 100644 --- a/doc/modules/kernel_approximation.rst +++ b/doc/modules/kernel_approximation.rst @@ -149,6 +149,51 @@ above for the :class:`RBFSampler`. The only difference is in the free parameter, that is called :math:`c`. For a motivation for this mapping and the mathematical details see [LS2010]_. +.. _polynomial_kernel_approx: + +Polynomial Kernel Approximation via Tensor Sketch +------------------------------------------------- + +The :ref:`polynomial kernel <polynomial_kernel>` is a popular type of kernel +function given by: + +.. math:: + + k(x, y) = (\gamma x^\top y +c_0)^d + +where: + + * ``x``, ``y`` are the input vectors + * ``d`` is the kernel degree + +Intuitively, the feature space of the polynomial kernel of degree `d` +consists of all possible degree-`d` products among input features, which enables +learning algorithms using this kernel to account for interactions between features. + +The TensorSketch [PP2013]_ method, as implemented in :class:`PolynomialCountSketch`, is a +scalable, input data independent method for polynomial kernel approximation. +It is based on the concept of Count sketch [WIKICS]_ [CCF2002]_ , a dimensionality +reduction technique similar to feature hashing, which instead uses several +independent hash functions. TensorSketch obtains a Count Sketch of the outer product +of two vectors (or a vector with itself), which can be used as an approximation of the +polynomial kernel feature space. In particular, instead of explicitly computing +the outer product, TensorSketch computes the Count Sketch of the vectors and then +uses polynomial multiplication via the Fast Fourier Transform to compute the +Count Sketch of their outer product. + +Conveniently, the training phase of TensorSketch simply consists of initializing +some random variables. It is thus independent of the input data, i.e. it only +depends on the number of input features, but not the data values. +In addition, this method can transform samples in +:math:`\mathcal{O}(n_{\text{samples}}(n_{\text{features}} + n_{\text{components}} \log(n_{\text{components}})))` +time, where :math:`n_{\text{components}}` is the desired output dimension, +determined by ``n_components``. + +.. topic:: Examples: + + * :ref:`sphx_glr_auto_examples_plot_scalable_poly_kernels.py` + +.. _tensor_sketch_kernel_approx: Mathematical Details -------------------- @@ -201,3 +246,11 @@ or store training examples. .. [VVZ2010] `"Generalized RBF feature maps for Efficient Detection" <https://www.robots.ox.ac.uk/~vgg/publications/2010/Sreekanth10/sreekanth10.pdf>`_ Vempati, S. and Vedaldi, A. and Zisserman, A. and Jawahar, CV - 2010 + .. [PP2013] `"Fast and scalable polynomial kernels via explicit feature maps" + <https://doi.org/10.1145/2487575.2487591>`_ + Pham, N., & Pagh, R. - 2013 + .. [CCF2002] `"Finding frequent items in data streams" + <http://www.cs.princeton.edu/courses/archive/spring04/cos598B/bib/CharikarCF.pdf>`_ + Charikar, M., Chen, K., & Farach-Colton - 2002 + .. [WIKICS] `"Wikipedia: Count sketch" + <https://en.wikipedia.org/wiki/Count_sketch>`_ diff --git a/doc/whats_new/v0.24.rst b/doc/whats_new/v0.24.rst index 2682902a20983..c73f1a373a86b 100644 --- a/doc/whats_new/v0.24.rst +++ b/doc/whats_new/v0.24.rst @@ -221,6 +221,15 @@ Changelog - \|Enhancement\| :class:`isotonic.IsotonicRegression` now accepts 2darray with 1 feature as input array. :pr:`17379` by :user:`Jiaxiang <fujiaxiang>`. +:mod:`sklearn.kernel_approximation` +................................... + +- \|Feature\| Added class :class:`kernel_approximation.PolynomialCountSketch` + which implements the Tensor Sketch algorithm for polynomial kernel feature + map approximation. + :pr:`13003` by :user:`Daniel López Sánchez <lopeLH>`. + + :mod:`sklearn.linear_model` ........................... @@ -235,6 +244,7 @@ Changelog efficient leave-one-out cross-validation scheme ``cv=None``. :pr:`6624` by :user:`Marijn van Vliet <wmvanvliet>`. + :mod:`sklearn.manifold` ....................... diff --git a/examples/plot_scalable_poly_kernels.py b/examples/plot_scalable_poly_kernels.py new file mode 100644 index 0000000000000..845ba1fdf3050 --- /dev/null +++ b/examples/plot_scalable_poly_kernels.py @@ -0,0 +1,186 @@ +""" +======================================================= +Scalable learning with polynomial kernel aproximation +======================================================= + +This example illustrates the use of :class:`PolynomialCountSketch` to +efficiently generate polynomial kernel feature-space approximations. +This is used to train linear classifiers that approximate the accuracy +of kernelized ones. + +.. currentmodule:: sklearn.kernel_approximation + +We use the Covtype dataset [2], trying to reproduce the experiments on the +original paper of Tensor Sketch [1], i.e. the algorithm implemented by +:class:`PolynomialCountSketch`. + +First, we compute the accuracy of a linear classifier on the original +features. Then, we train linear classifiers on different numbers of +features (`n_components`) generated by :class:`PolynomialCountSketch`, +approximating the accuracy of a kernelized classifier in a scalable manner. +""" +print(__doc__) + +# Author: Daniel Lopez-Sanchez <lope@usal.es> +# License: BSD 3 clause +import matplotlib.pyplot as plt +from sklearn.datasets import fetch_covtype +from sklearn.model_selection import train_test_split +from sklearn.preprocessing import MinMaxScaler, Normalizer +from sklearn.svm import LinearSVC +from sklearn.kernel_approximation import PolynomialCountSketch +from sklearn.pipeline import Pipeline, make_pipeline +import time + +# %% +# Load the Covtype dataset, which contains 581,012 samples +# with 54 features each, distributed among 6 classes. The goal of this dataset +# is to predict forest cover type from cartographic variables only +# (no remotely sensed data). After loading, we transform it into a binary +# classification problem to match the version of the dataset in the +# LIBSVM webpage [2], which was the one used in [1]. + +X, y = fetch_covtype(return_X_y=True) + +y[y != 2] = 0 +y[y == 2] = 1 # We will try to separate class 2 from the other 6 classes. + +# %% +# Here we select 5,000 samples for training and 10,000 for testing. +# To actually reproduce the results in the original Tensor Sketch paper, +# select 100,000 for training. + +X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=5_000, + test_size=10_000, + random_state=42) + +# %% +# Now scale features to the range [0, 1] to match the format of the dataset in +# the LIBSVM webpage, and then normalize to unit length as done in the +# original Tensor Sketch paper [1]. + +mm = make_pipeline(MinMaxScaler(), Normalizer()) +X_train = mm.fit_transform(X_train) +X_test = mm.transform(X_test) + + +# %% +# As a baseline, train a linear SVM on the original features and print the +# accuracy. We also measure and store accuracies and training times to +# plot them latter. + +results = {} + +lsvm = LinearSVC() +start = time.time() +lsvm.fit(X_train, y_train) +lsvm_time = time.time() - start +lsvm_score = 100 * lsvm.score(X_test, y_test) + +results["LSVM"] = {"time": lsvm_time, "score": lsvm_score} +print(f"Linear SVM score on raw features: {lsvm_score:.2f}%") + +# %% +# Then we train linear SVMs on the features generated by +# :class:`PolynomialCountSketch` with different values for `n_components`, +# showing that these kernel feature approximations improve the accuracy +# of linear classification. In typical application scenarios, `n_components` +# should be larger than the number of features in the input representation +# in order to achieve an improvement with respect to linear classification. +# As a rule of thumb, the optimum of evaluation score / run time cost is +# typically achieved at around `n_components` = 10 * `n_features`, though this +# might depend on the specific dataset being handled. Note that, since the +# original samples have 54 features, the explicit feature map of the +# polynomial kernel of degree four would have approximately 8.5 million +# features (precisely, 54^4). Thanks to :class:`PolynomialCountSketch`, we can +# condense most of the discriminative information of that feature space into a +# much more compact representation. We repeat the experiment 5 times to +# compensate for the stochastic nature of :class:`PolynomialCountSketch`. + +n_runs = 3 +for n_components in [250, 500, 1000, 2000]: + + ps_lsvm_time = 0 + ps_lsvm_score = 0 + for _ in range(n_runs): + + pipeline = Pipeline(steps=[("kernel_approximator", + PolynomialCountSketch( + n_components=n_components, + degree=4)), + ("linear_classifier", LinearSVC())]) + + start = time.time() + pipeline.fit(X_train, y_train) + ps_lsvm_time += time.time() - start + ps_lsvm_score += 100 * pipeline.score(X_test, y_test) + + ps_lsvm_time /= n_runs + ps_lsvm_score /= n_runs + + results[f"LSVM + PS({n_components})"] = { + "time": ps_lsvm_time, "score": ps_lsvm_score + } + print(f"Linear SVM score on {n_components} PolynomialCountSketch " + + f"features: {ps_lsvm_score:.2f}%") + +# %% +# Train a kernelized SVM to see how well :class:`PolynomialCountSketch` +# is approximating the performance of the kernel. This, of course, may take +# some time, as the SVC class has a relatively poor scalability. This is the +# reason why kernel approximators are so useful: + +from sklearn.svm import SVC + +ksvm = SVC(C=500., kernel="poly", degree=4, coef0=0, gamma=1.) + +start = time.time() +ksvm.fit(X_train, y_train) +ksvm_time = time.time() - start +ksvm_score = 100 * ksvm.score(X_test, y_test) + +results["KSVM"] = {"time": ksvm_time, "score": ksvm_score} +print(f"Kernel-SVM score on raw featrues: {ksvm_score:.2f}%") + +# %% +# Finally, plot the resuts of the different methods against their training +# times. As we can see, the kernelized SVM achieves a higher accuracy, +# but its training time is much larger and, most importantly, will grow +# much faster if the number of training samples increases. + +N_COMPONENTS = [250, 500, 1000, 2000] + +fig, ax = plt.subplots(figsize=(7, 7)) +ax.scatter([results["LSVM"]["time"], ], [results["LSVM"]["score"], ], + label="Linear SVM", c="green", marker="^") + +ax.scatter([results["LSVM + PS(250)"]["time"], ], + [results["LSVM + PS(250)"]["score"], ], + label="Linear SVM + PolynomialCountSketch", c="blue") +for n_components in N_COMPONENTS: + ax.scatter([results[f"LSVM + PS({n_components})"]["time"], ], + [results[f"LSVM + PS({n_components})"]["score"], ], + c="blue") + ax.annotate(f"n_comp.={n_components}", + (results[f"LSVM + PS({n_components})"]["time"], + results[f"LSVM + PS({n_components})"]["score"]), + xytext=(-30, 10), textcoords="offset pixels") + +ax.scatter([results["KSVM"]["time"], ], [results["KSVM"]["score"], ], + label="Kernel SVM", c="red", marker="x") + +ax.set_xlabel("Training time (s)") +ax.set_ylabel("Accurary (%)") +ax.legend() +plt.show() + +# %% +# References +# ========== +# +# [1] Pham, Ninh and Rasmus Pagh. "Fast and scalable polynomial kernels via +# explicit feature maps." KDD '13 (2013). +# https://doi.org/10.1145/2487575.2487591 +# +# [2] LIBSVM binary datasets repository +# https://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/binary.html diff --git a/sklearn/kernel_approximation.py b/sklearn/kernel_approximation.py index 0310523e63213..19b2c432a758f 100644 --- a/sklearn/kernel_approximation.py +++ b/sklearn/kernel_approximation.py @@ -1,10 +1,11 @@ """ The :mod:`sklearn.kernel_approximation` module implements several -approximate kernel feature maps base on Fourier transforms. +approximate kernel feature maps based on Fourier transforms and Count Sketches. """ # Author: Andreas Mueller <amueller@ais.uni-bonn.de> -# +# Daniel Lopez-Sanchez (TensorSketch) <lope@usal.es> + # License: BSD 3 clause import warnings @@ -12,6 +13,10 @@ import numpy as np import scipy.sparse as sp from scipy.linalg import svd +try: + from scipy.fft import fft, ifft +except ImportError: # scipy < 1.4 + from scipy.fftpack import fft, ifft from .base import BaseEstimator from .base import TransformerMixin @@ -22,6 +27,171 @@ from .utils.validation import check_non_negative, _deprecate_positional_args +class PolynomialCountSketch(BaseEstimator, TransformerMixin): + """Polynomial kernel approximation via Tensor Sketch. + + Implements Tensor Sketch, which approximates the feature map + of the polynomial kernel:: + + K(X, Y) = (gamma * <X, Y> + coef0)^degree + + by efficiently computing a Count Sketch of the outer product of a + vector with itself using Fast Fourier Transforms (FFT). Read more in the + :ref:`User Guide <polynomial_kernel_approx>`. + + Parameters + ---------- + gamma : float, default=1.0 + Parameter of the polynomial kernel whose feature map + will be approximated. + + degree : int, default=2 + Degree of the polynomial kernel whose feature map + will be approximated. + + coef0 : int, default=0 + Constant term of the polynomial kernel whose feature map + will be approximated. + + n_components : int, default=100 + Dimensionality of the output feature space. Usually, n_components + should be greater than the number of features in input samples in + order to achieve good performance. The optimal score / run time + balance is typically achieved around n_components = 10 * n_features, + but this depends on the specific dataset being used. + + random_state : int, RandomState instance, default=None + Determines random number generation for indexHash and bitHash + initialization. Pass an int for reproducible results across multiple + function calls. See :term:`Glossary <random_state>`. + + Attributes + ---------- + indexHash_ : ndarray of shape (degree, n_features), dtype=int64 + Array of indexes in range [0, n_components) used to represent + the 2-wise independent hash functions for Count Sketch computation. + + bitHash_ : ndarray of shape (degree, n_features), dtype=float32 + Array with random entries in {+1, -1}, used to represent + the 2-wise independent hash functions for Count Sketch computation. + + Examples + -------- + >>> from sklearn.kernel_approximation import PolynomialCountSketch + >>> from sklearn.linear_model import SGDClassifier + >>> X = [[0, 0], [1, 1], [1, 0], [0, 1]] + >>> y = [0, 0, 1, 1] + >>> ps = PolynomialCountSketch(degree=3, random_state=1) + >>> X_features = ps.fit_transform(X) + >>> clf = SGDClassifier(max_iter=10, tol=1e-3) + >>> clf.fit(X_features, y) + SGDClassifier(max_iter=10) + >>> clf.score(X_features, y) + 1.0 + """ + + def __init__(self, , gamma=1., degree=2, coef0=0, n_components=100, + random_state=None): + self.gamma = gamma + self.degree = degree + self.coef0 = coef0 + self.n_components = n_components + self.random_state = random_state + + def fit(self, X, y=None): + """Fit the model with X. + + Initializes the internal variables. The method needs no information + about the distribution of data, so we only care about n_features in X. + + Parameters + ---------- + X : {array-like, sparse matrix} of shape (n_samples, n_features) + Training data, where n_samples in the number of samples + and n_features is the number of features. + + Returns + ------- + self : object + Returns the transformer. + """ + if not self.degree >= 1: + raise ValueError(f"degree={self.degree} should be >=1.") + + X = self._validate_data(X, accept_sparse="csc") + random_state = check_random_state(self.random_state) + + n_features = X.shape[1] + if self.coef0 != 0: + n_features += 1 + + self.indexHash_ = random_state.randint(0, high=self.n_components, + size=(self.degree, n_features)) + + self.bitHash_ = random_state.choice(a=[-1, 1], + size=(self.degree, n_features)) + return self + + def transform(self, X): + """Generate the feature map approximation for X. + + Parameters + ---------- + X : {array-like}, shape (n_samples, n_features) + New data, where n_samples in the number of samples + and n_features is the number of features. + + Returns + ------- + X_new : array-like, shape (n_samples, n_components) + """ + + check_is_fitted(self) + X = self._validate_data(X, accept_sparse="csc") + + X_gamma = np.sqrt(self.gamma) X + + if sp.issparse(X_gamma) and self.coef0 != 0: + X_gamma = sp.hstack([X_gamma, np.sqrt(self.coef0) * + np.ones((X_gamma.shape[0], 1))], + format="csc") + + elif not sp.issparse(X_gamma) and self.coef0 != 0: + X_gamma = np.hstack([X_gamma, np.sqrt(self.coef0) * + np.ones((X_gamma.shape[0], 1))]) + + if X_gamma.shape[1] != self.indexHash_.shape[1]: + raise ValueError("Number of features of test samples does not" + " match that of training samples.") + + count_sketches = np.zeros( + (X_gamma.shape[0], self.degree, self.n_components)) + + if sp.issparse(X_gamma): + for j in range(X_gamma.shape[1]): + for d in range(self.degree): + iHashIndex = self.indexHash_[d, j] + iHashBit = self.bitHash_[d, j] + count_sketches[:, d, iHashIndex] += \ + (iHashBit * X_gamma[:, j]).toarray().ravel() + + else: + for j in range(X_gamma.shape[1]): + for d in range(self.degree): + iHashIndex = self.indexHash_[d, j] + iHashBit = self.bitHash_[d, j] + count_sketches[:, d, iHashIndex] += \ + iHashBit * X_gamma[:, j] + + # For each same, compute a count sketch of phi(x) using the polynomial + # multiplication (via FFT) of p count sketches of x. + count_sketches_fft = fft(count_sketches, axis=2, overwrite_x=True) + count_sketches_fft_prod = np.prod(count_sketches_fft, axis=1) + data_sketch = np.real(ifft(count_sketches_fft_prod, overwrite_x=True)) + + return data_sketch + + class RBFSampler(TransformerMixin, BaseEstimator): """Approximates feature map of an RBF kernel by Monte Carlo approximation of its Fourier transform.	diff --git a/sklearn/tests/test_kernel_approximation.py b/sklearn/tests/test_kernel_approximation.py index 8d37ce218f227..0cee04f9f2d0a 100644 --- a/sklearn/tests/test_kernel_approximation.py +++ b/sklearn/tests/test_kernel_approximation.py @@ -10,6 +10,7 @@ from sklearn.kernel_approximation import AdditiveChi2Sampler from sklearn.kernel_approximation import SkewedChi2Sampler from sklearn.kernel_approximation import Nystroem +from sklearn.kernel_approximation import PolynomialCountSketch from sklearn.metrics.pairwise import polynomial_kernel, rbf_kernel, chi2_kernel # generate data @@ -20,6 +21,40 @@ Y /= Y.sum(axis=1)[:, np.newaxis] +@pytest.mark.parametrize('degree', [-1, 0]) +def test_polynomial_count_sketch_raises_if_degree_lower_than_one(degree): + with pytest.raises(ValueError, match=f'degree={degree} should be >=1.'): + ps_transform = PolynomialCountSketch(degree=degree) + ps_transform.fit(X, Y) + + +@pytest.mark.parametrize('X', [X, csr_matrix(X)]) +@pytest.mark.parametrize('Y', [Y, csr_matrix(Y)]) +@pytest.mark.parametrize('gamma', [0.1, 1, 2.5]) +@pytest.mark.parametrize('degree', [1, 2, 3]) +@pytest.mark.parametrize('coef0', [0, 1, 2.5]) +def test_polynomial_count_sketch(X, Y, gamma, degree, coef0): + # test that PolynomialCountSketch approximates polynomial + # kernel on random data + + # compute exact kernel + kernel = polynomial_kernel(X, Y, gamma=gamma, degree=degree, coef0=coef0) + + # approximate kernel mapping + ps_transform = PolynomialCountSketch(n_components=5000, gamma=gamma, + coef0=coef0, degree=degree, + random_state=42) + X_trans = ps_transform.fit_transform(X) + Y_trans = ps_transform.transform(Y) + kernel_approx = np.dot(X_trans, Y_trans.T) + + error = kernel - kernel_approx + assert np.abs(np.mean(error)) <= 0.05 # close to unbiased + np.abs(error, out=error) + assert np.max(error) <= 0.1 # nothing too far off + assert np.mean(error) <= 0.05 # mean is fairly close + + def _linear_kernel(X, Y): return np.dot(X, Y.T)	diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 2e54d000a13aa..70a5174629f37 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -706,6 +706,7 @@ Plotting kernel_approximation.AdditiveChi2Sampler kernel_approximation.Nystroem + kernel_approximation.PolynomialCountSketch kernel_approximation.RBFSampler kernel_approximation.SkewedChi2Sampler diff --git a/doc/modules/kernel_approximation.rst b/doc/modules/kernel_approximation.rst index fb3843c6bc045..4f5ee46a42057 100644 --- a/doc/modules/kernel_approximation.rst +++ b/doc/modules/kernel_approximation.rst @@ -149,6 +149,51 @@ above for the :class:`RBFSampler`. The only difference is in the free parameter, that is called :math:`c`. For a motivation for this mapping and the mathematical details see [LS2010]_. +.. _polynomial_kernel_approx: + +Polynomial Kernel Approximation via Tensor Sketch +------------------------------------------------- + +The :ref:`polynomial kernel <polynomial_kernel>` is a popular type of kernel +function given by: + +.. math:: + + k(x, y) = (\gamma x^\top y +c_0)^d + +where: + + * ``x``, ``y`` are the input vectors + * ``d`` is the kernel degree + +Intuitively, the feature space of the polynomial kernel of degree `d` +consists of all possible degree-`d` products among input features, which enables +learning algorithms using this kernel to account for interactions between features. + +The TensorSketch [PP2013]_ method, as implemented in :class:`PolynomialCountSketch`, is a +scalable, input data independent method for polynomial kernel approximation. +It is based on the concept of Count sketch [WIKICS]_ [CCF2002]_ , a dimensionality +reduction technique similar to feature hashing, which instead uses several +independent hash functions. TensorSketch obtains a Count Sketch of the outer product +of two vectors (or a vector with itself), which can be used as an approximation of the +polynomial kernel feature space. In particular, instead of explicitly computing +the outer product, TensorSketch computes the Count Sketch of the vectors and then +uses polynomial multiplication via the Fast Fourier Transform to compute the +Count Sketch of their outer product. + +Conveniently, the training phase of TensorSketch simply consists of initializing +some random variables. It is thus independent of the input data, i.e. it only +depends on the number of input features, but not the data values. +In addition, this method can transform samples in +:math:`\mathcal{O}(n_{\text{samples}}(n_{\text{features}} + n_{\text{components}} \log(n_{\text{components}})))` +time, where :math:`n_{\text{components}}` is the desired output dimension, +determined by ``n_components``. + +.. topic:: Examples: + + * :ref:`sphx_glr_auto_examples_plot_scalable_poly_kernels.py` + +.. _tensor_sketch_kernel_approx: Mathematical Details -------------------- @@ -201,3 +246,11 @@ or store training examples. .. [VVZ2010] `"Generalized RBF feature maps for Efficient Detection" <https://www.robots.ox.ac.uk/~vgg/publications/2010/Sreekanth10/sreekanth10.pdf>`_ Vempati, S. and Vedaldi, A. and Zisserman, A. and Jawahar, CV - 2010 + .. [PP2013] `"Fast and scalable polynomial kernels via explicit feature maps" + <https://doi.org/10.1145/2487575.2487591>`_ + Pham, N., & Pagh, R. - 2013 + .. [CCF2002] `"Finding frequent items in data streams" + <http://www.cs.princeton.edu/courses/archive/spring04/cos598B/bib/CharikarCF.pdf>`_ + Charikar, M., Chen, K., & Farach-Colton - 2002 + .. [WIKICS] `"Wikipedia: Count sketch" + <https://en.wikipedia.org/wiki/Count_sketch>`_ diff --git a/doc/whats_new/v0.24.rst b/doc/whats_new/v0.24.rst index 2682902a20983..c73f1a373a86b 100644 --- a/doc/whats_new/v0.24.rst +++ b/doc/whats_new/v0.24.rst @@ -221,6 +221,15 @@ Changelog - \|Enhancement\| :class:`isotonic.IsotonicRegression` now accepts 2darray with 1 feature as input array. :pr:`17379` by :user:`Jiaxiang <fujiaxiang>`. +:mod:`sklearn.kernel_approximation` +................................... + +- \|Feature\| Added class :class:`kernel_approximation.PolynomialCountSketch` + which implements the Tensor Sketch algorithm for polynomial kernel feature + map approximation. + :pr:`13003` by :user:`Daniel López Sánchez <lopeLH>`. + + :mod:`sklearn.linear_model` ........................... @@ -235,6 +244,7 @@ Changelog efficient leave-one-out cross-validation scheme ``cv=None``. :pr:`6624` by :user:`Marijn van Vliet <wmvanvliet>`. + :mod:`sklearn.manifold` .......................	[ { "components": [ { "doc": "Polynomial kernel approximation via Tensor Sketch.\n\nImplements Tensor Sketch, which approximates the feature map\nof the polynomial kernel::\n\n K(X, Y) = (gamma * <X, Y> + coef0)^degree\n\nby efficiently computing a Count Sketch of the outer product of a\nvector w...	[ "sklearn/tests/test_kernel_approximation.py::test_polynomial_count_sketch_raises_if_degree_lower_than_one[-1]", "sklearn/tests/test_kernel_approximation.py::test_polynomial_count_sketch_raises_if_degree_lower_than_one[0]", "sklearn/tests/test_kernel_approximation.py::test_polynomial_count_sketch[0-1-0.1-Y0-X0]"...	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG+3] FEA Add PolynomialCountSketch to Kernel Approximation module This PR adds the Tensor Sketch [1] algorithm for polynomial kernel feature map approximation to the Kernel Approximation module. Tensor Sketch is a well established method for kernel feature map approximation, which has been broadly applied in the literature. For instance, it has recently gained a lot of popularity to accelerate certain bilinear models [2]. While the current kernel approximation module contains various kernel approximation methods, polynomial kernels are missing, so including TensorSketch completes the functionality of this module by providing an efficient and data-independent polynomial kernel approximation technique. The PR contains the implementation of the algorithm, the corresponding tests, an example script, and a description of the algorithm in the documentation page of the kernel approximation module. This implementation has been tested to produce the same results as the original matlab implementation provided by the author of the algorithm [1]. [1] [Pham, N., & Pagh, R. (2013, August). Fast and scalable polynomial kernels via explicit feature maps. In Proceedings of the 19th ACM SIGKDD international conference on Knowledge discovery and data mining (pp. 239-247). ACM.](https://scholar.google.es/scholar?hl=es&as_sdt=0%2C5&q=Fast+and+scalable+polynomial+kernels+via+explicit+feature+maps&btnG=) [2] [Gao, Y., Beijbom, O., Zhang, N., & Darrell, T. (2016). Compact bilinear pooling. In Proceedings of the IEEE conference on computer vision and pattern recognition (pp. 317-326).](https://scholar.google.es/scholar?hl=es&as_sdt=0%2C5&q=Compact+bilinear+pooling%2C+Y.+Gao&btnG=) _____ Work for follow-up PR: - [ ] @rth: This can be a follow up issue/PR, and would need double checking but since the count_sketches input is real you can likely use rfft and irfft witch would be faster. - [ ] @rth: The issue is that calling fit twice would produce a different seed and therefore a different result, since RandomState instance is mutable. In #14605 for a similar use case, we added a seed variable in transform, but I'm not particularly happy with that outcome either. This is probably fine as is, we would just have to address this globally at some point in #14042 - [ ] @rth: It could be worth considering whether it would make sense thesholding (in the above example 1e-15 would be ok as a threshold) and converting back to sparse. Though the intermediary step with the FFT would still be dense with the associated memory requirements, maybe it could be worth chunking with respect to n_samples not sure (https://github.com/scikit-learn/scikit-learn/pull/13003#issuecomment-673424927). ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/kernel_approximation.py] (definition of PolynomialCountSketch:) class PolynomialCountSketch(BaseEstimator, TransformerMixin): """Polynomial kernel approximation via Tensor Sketch. Implements Tensor Sketch, which approximates the feature map of the polynomial kernel:: K(X, Y) = (gamma * <X, Y> + coef0)^degree by efficiently computing a Count Sketch of the outer product of a vector with itself using Fast Fourier Transforms (FFT). Read more in the :ref:`User Guide <polynomial_kernel_approx>`. Parameters ---------- gamma : float, default=1.0 Parameter of the polynomial kernel whose feature map will be approximated. degree : int, default=2 Degree of the polynomial kernel whose feature map will be approximated. coef0 : int, default=0 Constant term of the polynomial kernel whose feature map will be approximated. n_components : int, default=100 Dimensionality of the output feature space. Usually, n_components should be greater than the number of features in input samples in order to achieve good performance. The optimal score / run time balance is typically achieved around n_components = 10 * n_features, but this depends on the specific dataset being used. random_state : int, RandomState instance, default=None Determines random number generation for indexHash and bitHash initialization. Pass an int for reproducible results across multiple function calls. See :term:`Glossary <random_state>`. Attributes ---------- indexHash_ : ndarray of shape (degree, n_features), dtype=int64 Array of indexes in range [0, n_components) used to represent the 2-wise independent hash functions for Count Sketch computation. bitHash_ : ndarray of shape (degree, n_features), dtype=float32 Array with random entries in {+1, -1}, used to represent the 2-wise independent hash functions for Count Sketch computation. Examples -------- >>> from sklearn.kernel_approximation import PolynomialCountSketch >>> from sklearn.linear_model import SGDClassifier >>> X = [[0, 0], [1, 1], [1, 0], [0, 1]] >>> y = [0, 0, 1, 1] >>> ps = PolynomialCountSketch(degree=3, random_state=1) >>> X_features = ps.fit_transform(X) >>> clf = SGDClassifier(max_iter=10, tol=1e-3) >>> clf.fit(X_features, y) SGDClassifier(max_iter=10) >>> clf.score(X_features, y) 1.0""" (definition of PolynomialCountSketch.__init__:) def __init__(self, *, gamma=1., degree=2, coef0=0, n_components=100, random_state=None): (definition of PolynomialCountSketch.fit:) def fit(self, X, y=None): """Fit the model with X. Initializes the internal variables. The method needs no information about the distribution of data, so we only care about n_features in X. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data, where n_samples in the number of samples and n_features is the number of features. Returns ------- self : object Returns the transformer.""" (definition of PolynomialCountSketch.transform:) def transform(self, X): """Generate the feature map approximation for X. Parameters ---------- X : {array-like}, shape (n_samples, n_features) New data, where n_samples in the number of samples and n_features is the number of features. Returns ------- X_new : array-like, shape (n_samples, n_components)""" [end of new definitions in sklearn/kernel_approximation.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		54ce4222694819ad52d544ce5cba5da274c34ab7
rytilahti__python-miio-451	451	rytilahti/python-miio	null	05f55bc6b6bea9cb0bc8a721e24631e0bac2ec39	2019-01-07T20:06:28Z	diff --git a/miio/airhumidifier.py b/miio/airhumidifier.py index 031d30c04..a143d1171 100644 --- a/miio/airhumidifier.py +++ b/miio/airhumidifier.py @@ -337,6 +337,20 @@ def set_led_brightness(self, brightness: LedBrightness): """Set led brightness.""" return self.send("set_led_b", [brightness.value]) + @command( + click.argument("led", type=bool), + default_output=format_output( + lambda led: "Turning on LED" + if led else "Turning off LED" + ) + ) + def set_led(self, led: bool): + """Turn led on/off.""" + if led: + return self.set_led_brightness(LedBrightness.Bright) + else: + return self.set_led_brightness(LedBrightness.Off) + @command( click.argument("buzzer", type=bool), default_output=format_output(	diff --git a/miio/tests/test_airhumidifier.py b/miio/tests/test_airhumidifier.py index a9bcfb973..af933d05f 100644 --- a/miio/tests/test_airhumidifier.py +++ b/miio/tests/test_airhumidifier.py @@ -147,6 +147,16 @@ def led_brightness(): self.device.set_led_brightness(LedBrightness.Off) assert led_brightness() == LedBrightness.Off + def test_set_led(self): + def led_brightness(): + return self.device.status().led_brightness + + self.device.set_led(True) + assert led_brightness() == LedBrightness.Bright + + self.device.set_led(False) + assert led_brightness() == LedBrightness.Off + def test_set_buzzer(self): def buzzer(): return self.device.status().buzzer @@ -343,6 +353,16 @@ def led_brightness(): self.device.set_led_brightness(LedBrightness.Off) assert led_brightness() == LedBrightness.Off + def test_set_led(self): + def led_brightness(): + return self.device.status().led_brightness + + self.device.set_led(True) + assert led_brightness() == LedBrightness.Bright + + self.device.set_led(False) + assert led_brightness() == LedBrightness.Off + def test_set_buzzer(self): def buzzer(): return self.device.status().buzzer		[ { "components": [ { "doc": "Turn led on/off.", "lines": [ 347, 352 ], "name": "AirHumidifier.set_led", "signature": "def set_led(self, led: bool):", "type": "function" } ], "file": "miio/airhumidifier.py" } ]	[ "miio/tests/test_airhumidifier.py::TestAirHumidifierV1::test_set_led", "miio/tests/test_airhumidifier.py::TestAirHumidifierCA1::test_set_led" ]	[ "miio/tests/test_airhumidifier.py::TestAirHumidifierV1::test_off", "miio/tests/test_airhumidifier.py::TestAirHumidifierV1::test_on", "miio/tests/test_airhumidifier.py::TestAirHumidifierV1::test_set_buzzer", "miio/tests/test_airhumidifier.py::TestAirHumidifierV1::test_set_child_lock", "miio/tests/test_airhum...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Air Humidifier: Add set_led method ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in miio/airhumidifier.py] (definition of AirHumidifier.set_led:) def set_led(self, led: bool): """Turn led on/off.""" [end of new definitions in miio/airhumidifier.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>		62427d2f796e603520acca3b57b29ec3e6489bca
conan-io__conan-4238	4,238	conan-io/conan	null	fe322a672307d29f99d2e7bc1c02c45c835028d7	2019-01-07T13:28:46Z	diff --git a/conans/util/sha.py b/conans/util/sha.py index 1e50aff2c80..026bfc98df8 100644 --- a/conans/util/sha.py +++ b/conans/util/sha.py @@ -7,3 +7,11 @@ def sha1(value): md = hashlib.sha1() md.update(value) return md.hexdigest() + + +def sha256(value): + if value is None: + return None + md = hashlib.sha256() + md.update(value) + return md.hexdigest() diff --git a/conans/util/windows.py b/conans/util/windows.py index b57dd1df2bc..3cb9e2497aa 100644 --- a/conans/util/windows.py +++ b/conans/util/windows.py @@ -4,8 +4,11 @@ from conans.util.env_reader import get_env from conans.util.files import load, mkdir, rmdir, save +from conans.util.log import logger +from conans.util.sha import sha256 CONAN_LINK = ".conan_link" +CONAN_REAL_PATH = "real_path.txt" def conan_expand_user(path): @@ -69,7 +72,15 @@ def path_shortener(path, short_paths): # cmd can fail if trying to set ACL in non NTFS drives, ignoring it. pass - redirect = tempfile.mkdtemp(dir=short_home, prefix="") + redirect = hashed_redirect(short_home, path) + if not redirect: + logger.warn("Failed to create a deterministic short path in %s", short_home) + redirect = tempfile.mkdtemp(dir=short_home, prefix="") + + # Save the full path of the local cache directory where the redirect is from. + # This file is for debugging purposes and not used by Conan. + save(os.path.join(redirect, CONAN_REAL_PATH), path) + # This "1" is the way to have a non-existing directory, so commands like # shutil.copytree() to it, works. It can be removed without compromising the # temp folder generator and conan-links consistency @@ -102,3 +113,17 @@ def rm_conandir(path): short_path = load(link) rmdir(os.path.dirname(short_path)) rmdir(path) + + +def hashed_redirect(base, path, min_length=6, attempts=10): + max_length = min_length + attempts + + full_hash = sha256(path.encode()) + assert len(full_hash) > max_length + + for length in range(min_length, max_length): + redirect = os.path.join(base, full_hash[:length]) + if not os.path.exists(redirect): + return redirect + else: + return None	diff --git a/conans/test/unittests/util/hashed_path_test.py b/conans/test/unittests/util/hashed_path_test.py new file mode 100644 index 00000000000..05b30f1bcfb --- /dev/null +++ b/conans/test/unittests/util/hashed_path_test.py @@ -0,0 +1,33 @@ +import os +import unittest + +from conans.test.utils.test_files import temp_folder + +from conans.util.windows import hashed_redirect + + +class HashedPathTest(unittest.TestCase): + def setUp(self): + self.path = "package_name/version/user/channel/export" + self.folder = temp_folder() + + def test_creates_deterministic_path(self): + first = hashed_redirect(self.folder, self.path) + second = hashed_redirect(self.folder, self.path) + self.assertEqual(first, second) + + def test_avoids_collisions(self): + first = hashed_redirect(self.folder, self.path) + os.mkdir(first) + + second = hashed_redirect(self.folder, self.path) + self.assertLess(len(first), len(second)) + + def test_give_up_if_cannot_avoid_collisions(self): + # Make two attempts to generate distinct path names + os.mkdir(hashed_redirect(self.folder, self.path)) + os.mkdir(hashed_redirect(self.folder, self.path)) + + # The two attempts were already spent, so the following should give up + redirect = hashed_redirect(self.folder, self.path, attempts=2) + self.assertEqual(None, redirect)		[ { "components": [ { "doc": "", "lines": [ 12, 17 ], "name": "sha256", "signature": "def sha256(value):", "type": "function" } ], "file": "conans/util/sha.py" }, { "components": [ { "doc": "", "l...	[ "conans/test/unittests/util/hashed_path_test.py::HashedPathTest::test_avoids_collisions", "conans/test/unittests/util/hashed_path_test.py::HashedPathTest::test_creates_deterministic_path", "conans/test/unittests/util/hashed_path_test.py::HashedPathTest::test_give_up_if_cannot_avoid_collisions" ]	[]	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feature/deterministic short paths Changelog: Feature: Generate deterministic short paths on Windows Docs: Omit Close #3971 This PR implements the generation of the deterministic paths on Windows. The feature was proposed and discussed in #3971. - [X] Refer to the issue that supports this Pull Request. - [X] If the issue has missing info, explain the purpose/use case/pain/need that covers this Pull Request. - [X] I've read the [Contributing guide](https://github.com/conan-io/conan/blob/develop/.github/CONTRIBUTING.md). - [X] I've followed the PEP8 style guides for Python code. - [ ] I've opened another PR in the Conan docs repo to the ``develop`` branch, documenting this one. <sup>Note: By default this PR will skip the slower tests and will use a limited set of python versions. Check [here](https://github.com/conan-io/conan/blob/develop/.github/PR_INCREASE_TESTING.md) how to increase the testing level by writing some tags in the current PR body text.</sup> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conans/util/sha.py] (definition of sha256:) def sha256(value): [end of new definitions in conans/util/sha.py] [start of new definitions in conans/util/windows.py] (definition of hashed_redirect:) def hashed_redirect(base, path, min_length=6, attempts=10): [end of new definitions in conans/util/windows.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> deterministic short_paths (the issue template is shamelessly stolen from https://github.com/concourse/concourse) ## What challenge are you facing? We're building a big C++ application in our CI system that uses many Conan packages. Build times can be as long as 1 hour so we use compilation caches (ccache/clcache) to speed up the build. This use case is also mentioned in #3502. Some of our Conan packages depend on the `short_paths` option, without this they don't build on Windows, at all. The problem is that the generated short paths aren't deterministic and this makes it impossible to re-use the compilation cache database on a different worker. Only worker-local cache is viable. Our workers are short lived, their virtual machines are destroyed and recreated daily. Using a worker-local compilation cache is sub-optimal because its lifetime is one day, hence the system needs multiple builds daily to warm up. ## What would make this better? A deterministic short path would allow the use of a global compilation cache greatly speeding up our builds. The following proposal builds upon the idea dicussed in #3502. Currently the `conans.util.windows.path_shortener` generates a redirect pointing to (using the default values): ``` C:\.conan\<random_name>\1 ``` Imagine, instead of this, having something like ``` C:\.conan\<deterministic_short_path>\1 ``` where the ``` deterministic_short_path = hash(name, version, user, channel, package_id) ``` In other words, all the path components appearing in the Conan data directory (available from `conan_reference` and `package_reference` in `conans.paths.py`) will be hashed to a single, deterministic value. To keep the path short we would truncate the output of a typical hash function such as MD5 or SHA. So the short path would look like: ``` C:\.conan\f5b96df\1 ``` This would also solve issues like #1881 ## Are you interested in implementing this yourself? If you think this proposal is feasible we would be very happy to implement this feature. ---------- The only problem with this approach, is the possibility of a collision. Known as the "birthday problem", the probability for 7 digits is here: https://github.com/source-foundry/font-v/issues/2#issuecomment-327189455 That will be not very likely, but still very possible. Might need to go for 8 digits. That is also 2 more than current random length, which also might eventually break some package that was really in the limit. I think it could make sense to take the risk, but need to discuss it. Thanks for the offer to implement it yourself! Will contact shortly if approved. @memsharded thanks for your quick response. The collisions are possible, however generated hashes don't have to be unique globally. The collisions need to be sufficiently rare on a particular host. Picking the right length is important, though. Using the simple [square approximation from this answer](https://stackoverflow.com/a/42567312) p ~= (n^2)/(2m) Where n is the number of items and m is the number of possibilities for each item. The number of possibilities for a hex string is 16^c where c is the number of characters. * n = 100, c=4 p ~= 0.08 * n = 1000, c = 6 gives p ~= 0.03 * n = 5000, c=7 gives p ~= 0.05 * n = 10000, c=8 gives p ~=0.01 I guess the question is how many packages a typical host has in its database (assuming that the short_path feature is always on). (co-author of proposal here) ... and, since these hashes would have meaning only locally, we could even consider a user-customizable parameter for the hash length if really needed. This would not solve the problem of the path being too long in certain unlucky cases, but it would solve the problem of the collisions if the local host has a huge number of packages. Yes, that means, that with a local cache of up to 1000 packages, if using 8 bits, the probability of collision would be around 0.0001 (0.01%) Discussing with @marco-m we could make the redirect collision-free if we implemented this as follows: * compute the hash * try to create the redirect using the first N characters * if this path already exists under `c:\.conan\` use an extra digit and try to create the redirect using the first N+1 characters Not sure it is enough @wagdav There is no guarantee that they will be evaluated in the same order Creating of short paths: - Pkg/1@user/channel => hash f12345 - Pkg2/1@user/channel => (collides) => hash f123456 If for some reason, not unlikely, a different run later that tries to use the same cache runs ``Pkg2/1@user/channel`` first, then won't it map to ``f12345``? Is there something I am missing? I think that the approach could work, @memsharded. In your scenario, if `Pkg2/1@user/channel` is created first, then it could be already in the cache (will use the previously used path stored in the CONAN_LINK file) or created again and look for a new tmp directory not existing in the cache. Something like this in the `path_shortener` function should work: ```python full_hash = hash_function(path) # Use path as input, all the settings/options/ids should already be there min_length = 4 # Any number will work max_length = 8 assert len(full_hash) > max_length # Should be easy enough for a hash function redirect = os.path.join(short_home, full_hash[:min_length]) while os.path.exists(redirect) and min_length != max_length: min_length += 1 redirect = os.path.join(short_home, full_hash[:min_length]) # If everything exists, then fallback to previous behaviour if min_length == max_length: redirect = tempfile.mkdtemp(dir=short_home, prefix="") ``` Main issue here: if you remove a package from the Conan cache, will the linked folder be removed too? If not, all the proposed `redirect` will eventually fail for packages that has been created and removed several times. After sharing this issue with the team, we are willing to accept this PR. The implementation should follow the idea above: - hash_function: any `sha` should be enough - let's get a deterministic path from `6` to `15` chars (fallback to `mkdtemp`). Although short paths should be erased when the path in the conan cache is deleted, we keep the _temp-dir_ fallback just in case there is a bug for any package and the short paths are not deleted. - add a _real_path.txt_ file inside the shortened path directory with the full path to the Conan cache it is linked from. This way we will be able to track the issue mentioned above. Thanks very much for offering your help @wagdav ! @memsharded, @lasote, @jgsogo we (@wagdav and myself, and surely also @piponazo) wanted to tell you that we admire how the Conan project treats contributors and users. You are doing a fantastic work. > hash_function: any sha should be enough this might be the case, but I would strongly advise against using sha-1. Even this might not be a security relevant thing in this use case (debatable), insecure hashing algorithm should just go away altogether. I would say it is counterproductive from a "big picture" point of view to introduce broken hashing algorithm in new code no matter the usage. (Also I'm pretty sure that I have heard that several e.g. government institutions are forbidden from using any software which contains broken hashing algorithm no matter the usage. But that was a while ago please don't pin me down on this.) I don't see any security concern here at all, so sha1 should be perfectly fine. We are taking a known, public path, and mapping it to another path. If someone has access to the system, then the smallest problem is this hash. Furthermore, we are just going to keep a very few 6-7-8 characters of it... Furthermore other hashing algorithms are already being used in Conan (md5 for file checksums, sha1 for https deduplication checks). There are plans to upgrade them, but at the moment I see no concern for using a sha1 at this moment. Even git is sha1 based :) :) :) Hi @wagdav , @marco-m did you have the chance to work on this? Would you need some help or guidance? I am tentatively assigning @wagdav this issue, but tell otherwise and we will plan for it. Thanks! > I don't see any security concern here at all Yes, but what I tried to say it no matter in what environment you are using it I don't think it is good to have a dependency on a broken hash algorithm. > There are plans to upgrade them, but at the moment I see no concern for using a sha1 at this moment. Even git is sha1 based :) :) :) Even more when you have plans to upgrade, why introducing SHA-1 now once more? And [git is actively working](https://github.com/git/git/blob/752414ae4310cd304f5e31649aaab2dcf307057c/Documentation/technical/hash-function-transition.txt) to get rid of of SHA-1 since [SHAttered](https://shattered.io) and settled for [SHA-256](https://github.com/git/git/commit/0ed8d8da374f648764758f13038ca93af87ab800). Maybe asking this in the other direction: is there a downside of using e.g. SHA-256? (even though, yes it gets cut of anyway and doesn't seem to be security relevant in this specific use case). Fair point, yes, lets do sha2 then. I was not arguing against it, I was arguing against the fact that using other algorithm here would imply some kind of vulnerability or insecurity in conan. Thanks! @memsharded Thanks for the follow-up! We didn't forget about this issue! We are planning to work on this next week! I'll let you know if we're blocked! @memsharded FYI we have to postpone to beginning of next year. Hi, we want to release this for Conan 1.12 at the end of the month. Would you be able to do it? We will do it otherwise Yes! We'll be submitting a PR next week! :crossed_fingers: -------------------- </issues>	4a5b19a75db9225316c8cb022a2dfb9705a2af34
scikit-learn__scikit-learn-12908	12,908	scikit-learn/scikit-learn	0.21	314686a65d543bd3b36d2af4b34ed23711991a57	2019-01-03T04:21:02Z	diff --git a/doc/modules/preprocessing.rst b/doc/modules/preprocessing.rst index 77abe294a331b..7b7c447beb34d 100644 --- a/doc/modules/preprocessing.rst +++ b/doc/modules/preprocessing.rst @@ -489,7 +489,7 @@ Continuing the example above:: >>> enc = preprocessing.OneHotEncoder() >>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']] >>> enc.fit(X) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - OneHotEncoder(categorical_features=None, categories=None, + OneHotEncoder(categorical_features=None, categories=None, drop=None, dtype=<... 'numpy.float64'>, handle_unknown='error', n_values=None, sparse=True) >>> enc.transform([['female', 'from US', 'uses Safari'], @@ -516,7 +516,7 @@ dataset:: >>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']] >>> enc.fit(X) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE OneHotEncoder(categorical_features=None, - categories=[...], + categories=[...], drop=None, dtype=<... 'numpy.float64'>, handle_unknown='error', n_values=None, sparse=True) >>> enc.transform([['female', 'from Asia', 'uses Chrome']]).toarray() @@ -533,13 +533,31 @@ columns for this feature will be all zeros >>> enc = preprocessing.OneHotEncoder(handle_unknown='ignore') >>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']] >>> enc.fit(X) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - OneHotEncoder(categorical_features=None, categories=None, + OneHotEncoder(categorical_features=None, categories=None, drop=None, dtype=<... 'numpy.float64'>, handle_unknown='ignore', n_values=None, sparse=True) >>> enc.transform([['female', 'from Asia', 'uses Chrome']]).toarray() array([[1., 0., 0., 0., 0., 0.]]) +It is also possible to encode each column into ``n_categories - 1`` columns +instead of ``n_categories`` columns by using the ``drop`` parameter. This +parameter allows the user to specify a category for each feature to be dropped. +This is useful to avoid co-linearity in the input matrix in some classifiers. +Such functionality is useful, for example, when using non-regularized +regression (:class:`LinearRegression <sklearn.linear_model.LinearRegression>`), +since co-linearity would cause the covariance matrix to be non-invertible. +When this paramenter is not None, ``handle_unknown`` must be set to +``error``:: + + >>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']] + >>> drop_enc = preprocessing.OneHotEncoder(drop='first').fit(X) + >>> drop_enc.categories_ + [array(['female', 'male'], dtype=object), array(['from Europe', 'from US'], dtype=object), array(['uses Firefox', 'uses Safari'], dtype=object)] + >>> drop_enc.transform(X).toarray() + array([[1., 1., 1.], + [0., 0., 0.]]) + See :ref:`dict_feature_extraction` for categorical features that are represented as a dict, not as scalars. diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 36582d834c708..f828c17a0c5fe 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -278,6 +278,11 @@ Support for Python 3.4 and below has been officially dropped. :class:`preprocessing.StandardScaler`. :issue:`13007` by :user:`Raffaello Baluyot <baluyotraf>` +- \|Feature\| :class:`OneHotEncoder` now supports dropping one feature per category + with a new drop parameter. :issue:`12908` by + :user:`Drew Johnston <drewmjohnston>`. + + :mod:`sklearn.tree` ................... - \|Feature\| Decision Trees can now be plotted with matplotlib using diff --git a/sklearn/preprocessing/_encoders.py b/sklearn/preprocessing/_encoders.py index be3e8a9967cfe..3560c3bfcfac0 100644 --- a/sklearn/preprocessing/_encoders.py +++ b/sklearn/preprocessing/_encoders.py @@ -2,7 +2,6 @@ # Joris Van den Bossche <jorisvandenbossche@gmail.com> # License: BSD 3 clause - import numbers import warnings @@ -158,6 +157,18 @@ class OneHotEncoder(_BaseEncoder): The used categories can be found in the ``categories_`` attribute. + drop : 'first' or a list/array of shape (n_features,), default=None. + Specifies a methodology to use to drop one of the categories per + feature. This is useful in situations where perfectly collinear + features cause problems, such as when feeding the resulting data + into a neural network or an unregularized regression. + + - None : retain all features (the default). + - 'first' : drop the first category in each feature. If only one + category is present, the feature will be dropped entirely. + - array : ``drop[i]`` is the category in feature ``X[:, i]`` that + should be dropped. + sparse : boolean, default=True Will return sparse matrix if set True else will return an array. @@ -205,7 +216,13 @@ class OneHotEncoder(_BaseEncoder): categories_ : list of arrays The categories of each feature determined during fitting (in order of the features in X and corresponding with the output - of ``transform``). + of ``transform``). This includes the category specified in ``drop`` + (if any). + + drop_idx_ : array of shape (n_features,) + ``drop_idx_[i]`` is the index in ``categories_[i]`` of the category to + be dropped for each feature. None if all the transformed features will + be retained. active_features_ : array Indices for active features, meaning values that actually occur @@ -243,9 +260,9 @@ class OneHotEncoder(_BaseEncoder): >>> enc.fit(X) ... # doctest: +ELLIPSIS ... # doctest: +NORMALIZE_WHITESPACE - OneHotEncoder(categorical_features=None, categories=None, - dtype=<... 'numpy.float64'>, handle_unknown='ignore', - n_values=None, sparse=True) + OneHotEncoder(categorical_features=None, categories=None, drop=None, + dtype=<... 'numpy.float64'>, handle_unknown='ignore', + n_values=None, sparse=True) >>> enc.categories_ [array(['Female', 'Male'], dtype=object), array([1, 2, 3], dtype=object)] @@ -257,6 +274,12 @@ class OneHotEncoder(_BaseEncoder): [None, 2]], dtype=object) >>> enc.get_feature_names() array(['x0_Female', 'x0_Male', 'x1_1', 'x1_2', 'x1_3'], dtype=object) + >>> drop_enc = OneHotEncoder(drop='first').fit(X) + >>> drop_enc.categories_ + [array(['Female', 'Male'], dtype=object), array([1, 2, 3], dtype=object)] + >>> drop_enc.transform([['Female', 1], ['Male', 2]]).toarray() + array([[0., 0., 0.], + [1., 1., 0.]]) See also -------- @@ -274,7 +297,7 @@ class OneHotEncoder(_BaseEncoder): """ def __init__(self, n_values=None, categorical_features=None, - categories=None, sparse=True, dtype=np.float64, + categories=None, drop=None, sparse=True, dtype=np.float64, handle_unknown='error'): self.categories = categories self.sparse = sparse @@ -282,6 +305,7 @@ def __init__(self, n_values=None, categorical_features=None, self.handle_unknown = handle_unknown self.n_values = n_values self.categorical_features = categorical_features + self.drop = drop # Deprecated attributes @@ -346,7 +370,6 @@ def _handle_deprecations(self, X): ) warnings.warn(msg, DeprecationWarning) else: - # check if we have integer or categorical input try: check_array(X, dtype=np.int) @@ -354,20 +377,38 @@ def _handle_deprecations(self, X): self._legacy_mode = False self._categories = 'auto' else: - msg = ( - "The handling of integer data will change in version " - "0.22. Currently, the categories are determined " - "based on the range [0, max(values)], while in the " - "future they will be determined based on the unique " - "values.\nIf you want the future behaviour and " - "silence this warning, you can specify " - "\"categories='auto'\".\n" - "In case you used a LabelEncoder before this " - "OneHotEncoder to convert the categories to integers, " - "then you can now use the OneHotEncoder directly." - ) - warnings.warn(msg, FutureWarning) - self._legacy_mode = True + if self.drop is None: + msg = ( + "The handling of integer data will change in " + "version 0.22. Currently, the categories are " + "determined based on the range " + "[0, max(values)], while in the future they " + "will be determined based on the unique " + "values.\nIf you want the future behaviour " + "and silence this warning, you can specify " + "\"categories='auto'\".\n" + "In case you used a LabelEncoder before this " + "OneHotEncoder to convert the categories to " + "integers, then you can now use the " + "OneHotEncoder directly." + ) + warnings.warn(msg, FutureWarning) + self._legacy_mode = True + else: + msg = ( + "The handling of integer data will change in " + "version 0.22. Currently, the categories are " + "determined based on the range " + "[0, max(values)], while in the future they " + "will be determined based on the unique " + "values.\n The old behavior is not compatible " + "with the `drop` parameter. Instead, you " + "must manually specify \"categories='auto'\" " + "if you wish to use the `drop` parameter on " + "an array of entirely integer data. This will " + "enable the future behavior." + ) + raise ValueError(msg) # if user specified categorical_features -> always use legacy mode if self.categorical_features is not None: @@ -399,6 +440,13 @@ def _handle_deprecations(self, X): else: self._categorical_features = 'all' + # Prevents new drop functionality from being used in legacy mode + if self._legacy_mode and self.drop is not None: + raise ValueError( + "The `categorical_features` and `n_values` keywords " + "are deprecated, and cannot be used together " + "with 'drop'.") + def fit(self, X, y=None): """Fit OneHotEncoder to X. @@ -411,10 +459,8 @@ def fit(self, X, y=None): ------- self """ - if self.handle_unknown not in ('error', 'ignore'): - msg = ("handle_unknown should be either 'error' or 'ignore', " - "got {0}.".format(self.handle_unknown)) - raise ValueError(msg) + + self._validate_keywords() self._handle_deprecations(X) @@ -425,8 +471,59 @@ def fit(self, X, y=None): return self else: self._fit(X, handle_unknown=self.handle_unknown) + self.drop_idx_ = self._compute_drop_idx() return self + def _compute_drop_idx(self): + if self.drop is None: + return None + elif (isinstance(self.drop, str) and self.drop == 'first'): + return np.zeros(len(self.categories_), dtype=np.int_) + elif not isinstance(self.drop, str): + try: + self.drop = np.asarray(self.drop, dtype=object) + droplen = len(self.drop) + except (ValueError, TypeError): + msg = ("Wrong input for parameter `drop`. Expected " + "'first', None or array of objects, got {}") + raise ValueError(msg.format(type(self.drop))) + if droplen != len(self.categories_): + msg = ("`drop` should have length equal to the number " + "of features ({}), got {}") + raise ValueError(msg.format(len(self.categories_), + len(self.drop))) + missing_drops = [(i, val) for i, val in enumerate(self.drop) + if val not in self.categories_[i]] + if any(missing_drops): + msg = ("The following categories were supposed to be " + "dropped, but were not found in the training " + "data.\n{}".format( + "\n".join( + ["Category: {}, Feature: {}".format(c, v) + for c, v in missing_drops]))) + raise ValueError(msg) + return np.array([np.where(cat_list == val)[0][0] + for (val, cat_list) in + zip(self.drop, self.categories_)], dtype=np.int_) + else: + msg = ("Wrong input for parameter `drop`. Expected " + "'first', None or array of objects, got {}") + raise ValueError(msg.format(type(self.drop))) + + def _validate_keywords(self): + if self.handle_unknown not in ('error', 'ignore'): + msg = ("handle_unknown should be either 'error' or 'ignore', " + "got {0}.".format(self.handle_unknown)) + raise ValueError(msg) + # If we have both dropped columns and ignored unknown + # values, there will be ambiguous cells. This creates difficulties + # in interpreting the model. + if self.drop is not None and self.handle_unknown != 'error': + raise ValueError( + "`handle_unknown` must be 'error' when the drop parameter is " + "specified, as both would create categories that are all " + "zero.") + def _legacy_fit_transform(self, X): """Assumes X contains only categorical features.""" dtype = getattr(X, 'dtype', None) @@ -501,10 +598,8 @@ def fit_transform(self, X, y=None): X_out : sparse matrix if sparse=True else a 2-d array Transformed input. """ - if self.handle_unknown not in ('error', 'ignore'): - msg = ("handle_unknown should be either 'error' or 'ignore', " - "got {0}.".format(self.handle_unknown)) - raise ValueError(msg) + + self._validate_keywords() self._handle_deprecations(X) @@ -571,11 +666,22 @@ def _transform_new(self, X): X_int, X_mask = self._transform(X, handle_unknown=self.handle_unknown) + if self.drop is not None: + to_drop = self.drop_idx_.reshape(1, -1) + + # We remove all the dropped categories from mask, and decrement all + # categories that occur after them to avoid an empty column. + + keep_cells = X_int != to_drop + X_mask &= keep_cells + X_int[X_int > to_drop] -= 1 + n_values = [len(cats) - 1 for cats in self.categories_] + else: + n_values = [len(cats) for cats in self.categories_] + mask = X_mask.ravel() - n_values = [cats.shape[0] for cats in self.categories_] n_values = np.array([0] + n_values) feature_indices = np.cumsum(n_values) - indices = (X_int + feature_indices[:-1]).ravel()[mask] indptr = X_mask.sum(axis=1).cumsum() indptr = np.insert(indptr, 0, 0) @@ -613,7 +719,7 @@ def transform(self, X): def inverse_transform(self, X): """Convert the back data to the original representation. - In case unknown categories are encountered (all zero's in the + In case unknown categories are encountered (all zeros in the one-hot encoding), ``None`` is used to represent this category. Parameters @@ -635,7 +741,12 @@ def inverse_transform(self, X): n_samples, _ = X.shape n_features = len(self.categories_) - n_transformed_features = sum([len(cats) for cats in self.categories_]) + if self.drop is None: + n_transformed_features = sum(len(cats) + for cats in self.categories_) + else: + n_transformed_features = sum(len(cats) - 1 + for cats in self.categories_) # validate shape of passed X msg = ("Shape of the passed X data is not correct. Expected {0} " @@ -651,18 +762,35 @@ def inverse_transform(self, X): found_unknown = {} for i in range(n_features): - n_categories = len(self.categories_[i]) + if self.drop is None: + cats = self.categories_[i] + else: + cats = np.delete(self.categories_[i], self.drop_idx_[i]) + n_categories = len(cats) + + # Only happens if there was a column with a unique + # category. In this case we just fill the column with this + # unique category value. + if n_categories == 0: + X_tr[:, i] = self.categories_[i][self.drop_idx_[i]] + j += n_categories + continue sub = X[:, j:j + n_categories] - # for sparse X argmax returns 2D matrix, ensure 1D array labels = np.asarray(_argmax(sub, axis=1)).flatten() - X_tr[:, i] = self.categories_[i][labels] - + X_tr[:, i] = cats[labels] if self.handle_unknown == 'ignore': - # ignored unknown categories: we have a row of all zero's unknown = np.asarray(sub.sum(axis=1) == 0).flatten() + # ignored unknown categories: we have a row of all zero if unknown.any(): found_unknown[i] = unknown + # drop will either be None or handle_unknown will be error. If + # self.drop is not None, then we can safely assume that all of + # the nulls in each column are the dropped value + elif self.drop is not None: + dropped = np.asarray(sub.sum(axis=1) == 0).flatten() + if dropped.any(): + X_tr[dropped, i] = self.categories_[i][self.drop_idx_[i]] j += n_categories	diff --git a/sklearn/preprocessing/tests/test_encoders.py b/sklearn/preprocessing/tests/test_encoders.py index 93b1de018d2e9..2734e61128beb 100644 --- a/sklearn/preprocessing/tests/test_encoders.py +++ b/sklearn/preprocessing/tests/test_encoders.py @@ -96,6 +96,20 @@ def test_one_hot_encoder_sparse(): enc.fit([[0], [1]]) assert_raises(ValueError, enc.transform, [[0], [-1]]) + with ignore_warnings(category=(DeprecationWarning, FutureWarning)): + enc = OneHotEncoder(drop='first', n_values=1) + for method in (enc.fit, enc.fit_transform): + assert_raises_regex( + ValueError, + 'The `categorical_features` and `n_values` keywords ', + method, [[0], [-1]]) + + enc = OneHotEncoder(drop='first', categorical_features='all') + assert_raises_regex( + ValueError, + 'The `categorical_features` and `n_values` keywords ', + method, [[0], [-1]]) + def test_one_hot_encoder_dense(): # check for sparse=False @@ -278,7 +292,7 @@ def test_one_hot_encoder_no_categorical_features(): enc = OneHotEncoder(categorical_features=cat) with ignore_warnings(category=(DeprecationWarning, FutureWarning)): X_tr = enc.fit_transform(X) - expected_features = np.array(list(), dtype='object') + expected_features = np.array([], dtype='object') assert_array_equal(X, X_tr) assert_array_equal(enc.get_feature_names(), expected_features) assert enc.categories_ == [] @@ -373,21 +387,25 @@ def test_one_hot_encoder(X): assert_allclose(Xtr.toarray(), [[0, 1, 1, 0, 1], [1, 0, 0, 1, 1]]) -def test_one_hot_encoder_inverse(): - for sparse_ in [True, False]: - X = [['abc', 2, 55], ['def', 1, 55], ['abc', 3, 55]] - enc = OneHotEncoder(sparse=sparse_) - X_tr = enc.fit_transform(X) - exp = np.array(X, dtype=object) - assert_array_equal(enc.inverse_transform(X_tr), exp) +@pytest.mark.parametrize('sparse_', [False, True]) +@pytest.mark.parametrize('drop', [None, 'first']) +def test_one_hot_encoder_inverse(sparse_, drop): + X = [['abc', 2, 55], ['def', 1, 55], ['abc', 3, 55]] + enc = OneHotEncoder(sparse=sparse_, drop=drop) + X_tr = enc.fit_transform(X) + exp = np.array(X, dtype=object) + assert_array_equal(enc.inverse_transform(X_tr), exp) - X = [[2, 55], [1, 55], [3, 55]] - enc = OneHotEncoder(sparse=sparse_, categories='auto') - X_tr = enc.fit_transform(X) - exp = np.array(X) - assert_array_equal(enc.inverse_transform(X_tr), exp) + X = [[2, 55], [1, 55], [3, 55]] + enc = OneHotEncoder(sparse=sparse_, categories='auto', + drop=drop) + X_tr = enc.fit_transform(X) + exp = np.array(X) + assert_array_equal(enc.inverse_transform(X_tr), exp) + if drop is None: # with unknown categories + # drop is incompatible with handle_unknown=ignore X = [['abc', 2, 55], ['def', 1, 55], ['abc', 3, 55]] enc = OneHotEncoder(sparse=sparse_, handle_unknown='ignore', categories=[['abc', 'def'], [1, 2], @@ -407,10 +425,10 @@ def test_one_hot_encoder_inverse(): exp[:, 1] = None assert_array_equal(enc.inverse_transform(X_tr), exp) - # incorrect shape raises - X_tr = np.array([[0, 1, 1], [1, 0, 1]]) - msg = re.escape('Shape of the passed X data is not correct') - assert_raises_regex(ValueError, msg, enc.inverse_transform, X_tr) + # incorrect shape raises + X_tr = np.array([[0, 1, 1], [1, 0, 1]]) + msg = re.escape('Shape of the passed X data is not correct') + assert_raises_regex(ValueError, msg, enc.inverse_transform, X_tr) @pytest.mark.parametrize("X, cat_exp, cat_dtype", [ @@ -687,3 +705,90 @@ def test_one_hot_encoder_warning(): enc = OneHotEncoder() X = [['Male', 1], ['Female', 3]] np.testing.assert_no_warnings(enc.fit_transform, X) + + +def test_one_hot_encoder_drop_manual(): + cats_to_drop = ['def', 12, 3, 56] + enc = OneHotEncoder(drop=cats_to_drop) + X = [['abc', 12, 2, 55], + ['def', 12, 1, 55], + ['def', 12, 3, 56]] + trans = enc.fit_transform(X).toarray() + exp = [[1, 0, 1, 1], + [0, 1, 0, 1], + [0, 0, 0, 0]] + assert_array_equal(trans, exp) + dropped_cats = [cat[feature] + for cat, feature in zip(enc.categories_, + enc.drop_idx_)] + assert_array_equal(dropped_cats, cats_to_drop) + assert_array_equal(np.array(X, dtype=object), + enc.inverse_transform(trans)) + + +def test_one_hot_encoder_invalid_params(): + enc = OneHotEncoder(drop='second') + assert_raises_regex( + ValueError, + "Wrong input for parameter `drop`.", + enc.fit, [["Male"], ["Female"]]) + + enc = OneHotEncoder(handle_unknown='ignore', drop='first') + assert_raises_regex( + ValueError, + "`handle_unknown` must be 'error'", + enc.fit, [["Male"], ["Female"]]) + + enc = OneHotEncoder(drop='first') + assert_raises_regex( + ValueError, + "The handling of integer data will change in version", + enc.fit, [[1], [2]]) + + enc = OneHotEncoder(drop='first', categories='auto') + assert_no_warnings(enc.fit_transform, [[1], [2]]) + + enc = OneHotEncoder(drop=np.asarray('b', dtype=object)) + assert_raises_regex( + ValueError, + "Wrong input for parameter `drop`.", + enc.fit, [['abc', 2, 55], ['def', 1, 55], ['def', 3, 59]]) + + enc = OneHotEncoder(drop=['ghi', 3, 59]) + assert_raises_regex( + ValueError, + "The following categories were supposed", + enc.fit, [['abc', 2, 55], ['def', 1, 55], ['def', 3, 59]]) + + +@pytest.mark.parametrize('drop', [['abc', 3], ['abc', 3, 41, 'a']]) +def test_invalid_drop_length(drop): + enc = OneHotEncoder(drop=drop) + assert_raises_regex( + ValueError, + "`drop` should have length equal to the number", + enc.fit, [['abc', 2, 55], ['def', 1, 55], ['def', 3, 59]]) + + +@pytest.mark.parametrize("density", [True, False], + ids=['sparse', 'dense']) +@pytest.mark.parametrize("drop", ['first', + ['a', 2, 'b']], + ids=['first', 'manual']) +def test_categories(density, drop): + ohe_base = OneHotEncoder(sparse=density) + ohe_test = OneHotEncoder(sparse=density, drop=drop) + X = [['c', 1, 'a'], + ['a', 2, 'b']] + ohe_base.fit(X) + ohe_test.fit(X) + assert_array_equal(ohe_base.categories_, ohe_test.categories_) + if drop == 'first': + assert_array_equal(ohe_test.drop_idx_, 0) + else: + for drop_cat, drop_idx, cat_list in zip(drop, + ohe_test.drop_idx_, + ohe_test.categories_): + assert cat_list[drop_idx] == drop_cat + assert isinstance(ohe_test.drop_idx_, np.ndarray) + assert ohe_test.drop_idx_.dtype == np.int_	diff --git a/doc/modules/preprocessing.rst b/doc/modules/preprocessing.rst index 77abe294a331b..7b7c447beb34d 100644 --- a/doc/modules/preprocessing.rst +++ b/doc/modules/preprocessing.rst @@ -489,7 +489,7 @@ Continuing the example above:: >>> enc = preprocessing.OneHotEncoder() >>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']] >>> enc.fit(X) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - OneHotEncoder(categorical_features=None, categories=None, + OneHotEncoder(categorical_features=None, categories=None, drop=None, dtype=<... 'numpy.float64'>, handle_unknown='error', n_values=None, sparse=True) >>> enc.transform([['female', 'from US', 'uses Safari'], @@ -516,7 +516,7 @@ dataset:: >>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']] >>> enc.fit(X) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE OneHotEncoder(categorical_features=None, - categories=[...], + categories=[...], drop=None, dtype=<... 'numpy.float64'>, handle_unknown='error', n_values=None, sparse=True) >>> enc.transform([['female', 'from Asia', 'uses Chrome']]).toarray() @@ -533,13 +533,31 @@ columns for this feature will be all zeros >>> enc = preprocessing.OneHotEncoder(handle_unknown='ignore') >>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']] >>> enc.fit(X) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - OneHotEncoder(categorical_features=None, categories=None, + OneHotEncoder(categorical_features=None, categories=None, drop=None, dtype=<... 'numpy.float64'>, handle_unknown='ignore', n_values=None, sparse=True) >>> enc.transform([['female', 'from Asia', 'uses Chrome']]).toarray() array([[1., 0., 0., 0., 0., 0.]]) +It is also possible to encode each column into ``n_categories - 1`` columns +instead of ``n_categories`` columns by using the ``drop`` parameter. This +parameter allows the user to specify a category for each feature to be dropped. +This is useful to avoid co-linearity in the input matrix in some classifiers. +Such functionality is useful, for example, when using non-regularized +regression (:class:`LinearRegression <sklearn.linear_model.LinearRegression>`), +since co-linearity would cause the covariance matrix to be non-invertible. +When this paramenter is not None, ``handle_unknown`` must be set to +``error``:: + + >>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']] + >>> drop_enc = preprocessing.OneHotEncoder(drop='first').fit(X) + >>> drop_enc.categories_ + [array(['female', 'male'], dtype=object), array(['from Europe', 'from US'], dtype=object), array(['uses Firefox', 'uses Safari'], dtype=object)] + >>> drop_enc.transform(X).toarray() + array([[1., 1., 1.], + [0., 0., 0.]]) + See :ref:`dict_feature_extraction` for categorical features that are represented as a dict, not as scalars. diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 36582d834c708..f828c17a0c5fe 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -278,6 +278,11 @@ Support for Python 3.4 and below has been officially dropped. :class:`preprocessing.StandardScaler`. :issue:`13007` by :user:`Raffaello Baluyot <baluyotraf>` +- \|Feature\| :class:`OneHotEncoder` now supports dropping one feature per category + with a new drop parameter. :issue:`12908` by + :user:`Drew Johnston <drewmjohnston>`. + + :mod:`sklearn.tree` ................... - \|Feature\| Decision Trees can now be plotted with matplotlib using	[ { "components": [ { "doc": "", "lines": [ 477, 511 ], "name": "OneHotEncoder._compute_drop_idx", "signature": "def _compute_drop_idx(self):", "type": "function" }, { "doc": "", "lines": [ 513, ...	[ "sklearn/preprocessing/tests/test_encoders.py::test_one_hot_encoder_sparse", "sklearn/preprocessing/tests/test_encoders.py::test_one_hot_encoder_inverse[None-False]", "sklearn/preprocessing/tests/test_encoders.py::test_one_hot_encoder_inverse[None-True]", "sklearn/preprocessing/tests/test_encoders.py::test_on...	[ "sklearn/preprocessing/tests/test_encoders.py::test_one_hot_encoder_dense", "sklearn/preprocessing/tests/test_encoders.py::test_one_hot_encoder_deprecationwarnings", "sklearn/preprocessing/tests/test_encoders.py::test_one_hot_encoder_force_new_behaviour", "sklearn/preprocessing/tests/test_encoders.py::test_on...	This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG + 2] Add Drop Option to OneHotEncoder. #### Reference Issues/PRs Fixes #6488 and fixes #6053. This builds upon some of the code from #12884 (thanks @NicolasHug!), but also incorporates functionality which lets the user manually specify which category in each column they would like to be dropped, so this is a more general solution along the lines of what @amueller suggested in #6053. This is useful in some cases (such as OLS regression) where the dropped group affects the interpretation of coefficients. This should also fix #9361, which has less functionality and appears stalled. #### What does this implement/fix? Explain your changes. This code implements a new parameter (drop) in the OneHotEncoder, which can take any of three values: None (default), which implements the existing behavior. 'first', which drops the first value in each category. list of length n_features, which allows for the manual specification of the reference group. #### Any other comments? This new feature does not work in Legacy mode (this was discussed in #6053), and it requires the manual specification of "categories='auto'" in the case in which the input is all integers, so as not to interfere with the ongoing change in the treatment of integers in OneHotEncoder. This code is also incompatible with "handle_missing='ignore'", since in that case it is not possible to determine which categories are 0 because they are in the reference category and which are all 0 due to missing data. Closes #12884 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/preprocessing/_encoders.py] (definition of OneHotEncoder._compute_drop_idx:) def _compute_drop_idx(self): (definition of OneHotEncoder._validate_keywords:) def _validate_keywords(self): [end of new definitions in sklearn/preprocessing/_encoders.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>	Here is the discussion in the issues of the pull request. <issues> OneHotEncoder - add option for 1 of k-1 encoding Like the title says. Would it be possible to add an option, say "independent = True" to OneHotEncoder that would return a 1 of k-1 encoding instead of a 1 of k encoding. This would be very useful to me when I am encoding categorical variables since the 1 of k encoding adds an extra (non-independent) degree of freedom to the model. It would also be nice if I could specify which category to keep as the baseline. Something like: ``` X = np.array([12,24,36]).reshape(-1,1) OneHotEncoder(sparse=False, independent=True, baseline=24).fit_transform(X) Output: array([[ 1., 0.], [ 0., 0.], [ 0., 1.]]) ``` ---------- I guess we could do that as many people ask about it. I don't think there is that much of a point in doing that. Nearly all the models in scikit-learn are regularized, so this doesn't matter afaik. I guess you are using a linear model? @vighneshbirodkar is working on the `OneHotEncoder`, it might be worth waiting till that is finished. Yup. I'm using a linear regression on categorical variables. So actually no regularization. The regression works fine so there must be a fix for collinearity (non invertibility) in `scipy.linalg.lstsq` but I find this way of building a model a bit confusing. The solution to the least squared problem with collinearity is under determined - there is a family of solutions. And so to solve it there is some behind the scenes choice being made as to _the_ solution which is hidden from the user. Basically I'd rather not introduce collinearity into a model that will then have to deal with that collinearity. This is all obviously just my under informed opinion :) Why are you not using regularization? I think the main reason people don't use regularization is that they want simple statistics on the coefficients. But scikit-learn doesn't provide any statistics of the coefficients. Maybe statsmodels would be a better fit for your application. If you are interested in predictive performance, just replace `LinearRegression` with `RidgeCV` and your predictions will improve. Ok. I guess regularization is the way to go in scikit-learn. I do still disagree in that I think dependence shouldn't be introduced into the model by way of preprocessors (or at least there should be an option to turn this off). But maybe this is getting at the difference between machine learning and statistical modelling. Or maybe who cares about independence if we have regularization. Sorry for the slow reply. I'm ok with adding an option to turn this off. But as I said, OneHotEncoder is still being refactored. I've elsewhere discussed similar for `LabelBinarizer` in the multiclass case, proposing the parameter name `drop_first` to ignore the encoding of the smallest value. --------------------OneHotEncoding - Defining a reference category In order to avoid multicollinearity in modelling, the number of dummy-coded variables needed should be one less than the number of categories. Therefore, it would be very code if OneHotEncoding could accept a reference category as an input variable. ---------- not sure if that was raise somewhere already. multicollinearity is really not a problem in any model in scikit-learn. But feel free to create a pull-request. The OneHotEncoder is being restructured quite heavily right now, though. I'm interested in working on this feature! I ran into some problems using a OneHotEncoder in a pipeline that used a Keras Neural Network as the classifier. I was attempting to transform a few columns of categorical features into a dummy variable representation and feed the resulting columns (plus some numerical variables that were passed through) into the NN for classification. However, the one hot encoding played poorly with the collinear columns, and my model performed poorly out of sample. I was eventually able to design a workaround, but it seems to me that it would be valuable to have a tool in scikit-learn that could do this simply. I see the above pull request, which began to implement this in the DictVectorizer class, but it looks like this was never implemented (probably due to some unresolved fixes that were suggested). Is there anything stopping this from being implemented in the OneHotEncoder case instead? I think we'd accept a PR. I'm a bit surprised there's none yet. We also changed the OneHotEncoder quite a bit recently. You probably don't want to modify the "legacy" mode. A question is whether/how we allow users to specify which category to drop. In regularized models this actually makes a difference IIRC. We could have a parameter ``drop`` that's ``'none'`` by default, and could be ``'first'`` or a datastructure with the values to drop. could be a list/numpy array of length n_features (all input features are categorical in the new OneHotEncoder). Reading through the comments on the old PR, I was thinking that those options seem to be the natural choice. I'm in the midst of graduate school applications right now so my time is somewhat limited, but this seems to be something that is going to keep appearing in my work, so I'm going to have to address this (or keep using workarounds) at some point. On Wed, Nov 28, 2018 at 3:49 PM Andreas Mueller <notifications@github.com> wrote: > I think we'd accept a PR. I'm a bit surprised there's none yet. We also > changed the OneHotEncoder quite a bit recently. You probably don't want to > modify the "legacy" mode. A question is whether/how we allow users to > specify which category to drop. In regularized models this actually makes a > difference IIRC. > We could have a parameter drop that's 'none' by default, and could be > 'first' or a datastructure with the values to drop. could be a list/numpy > array of length n_features (all input features are categorical in the new > OneHotEncoder). > > — > You are receiving this because you commented. > Reply to this email directly, view it on GitHub > <https://github.com/scikit-learn/scikit-learn/issues/6053#issuecomment-442599181>, > or mute the thread > <https://github.com/notifications/unsubscribe-auth/Am4ucQaSxhMTVGCeWx4cy-xx5Xl3EHmOks5uzvbugaJpZM4G2bMF> > . > --------------------[MRG] ENH: add support for dropping first level of categorical feature #### Reference Issues Fixes #6053 Fixes #9073 #### What does this implement/fix? Explain your changes. This Pull Request adds an extra argument to `DictVectorizer` that, if set to `True`, drops the first level of each categorical variable. This is extremely useful in a regression model that to not use regularisation, as it avoids multicollinearity. #### Any other comments Even though multicollinearity doesn't affect the predictions, it hugely affects the regression coefficients, which makes troublesome both model inspection and further usage of such coefficients. ---------- @jnothman are you happy with the changes I made? Feel free to leave additional comments if you find something that can be improved. I'm hoping to start working on some new bug fix as soon as this weekend. I think you'd best adopt something like my approach. Imagine someone analysing the most stable important features under control validation. If the feature dropped differs for each cv split, the results are uninterpretable On 21 Jul 2017 6:43 am, "Gianluca Rossi" <notifications@github.com> wrote: @IamGianluca commented on this pull request. ------------------------------ In sklearn/feature_extraction/dict_vectorizer.py <https://github.com/scikit-learn/scikit-learn/pull/9361#discussion_r128625938> : > for x in X: for f, v in six.iteritems(x): if isinstance(v, six.string_types): + if self.drop_first_category and f not in to_drop: Hi Joel, I like your solution! I've intentionally avoided splitting the string using a separator to overcome issues of ambiguity ― I hope people don't ever use the = character in columns names, but you never know :-) Let me know if you want me to implement your suggestion, and I'll update my PR. I also fear this is too sensitive to the ordering of the data for the user to find it explicable. That's a valid point. In my own project to overcome such problem, I've stored the dictionaries that I want to pass to DictVectorizer inside a "master" dictionary. This master dictionary has keys that can be sorted in a way that guarantees the first category is deterministic. x = vectorizer.fit_transform([v for k, v in sorted(master.items())]) In this example a key in master could be something like the following tuple: (582498109, 'Desktop') ... where Desktop is the level I want to drop, and each id (the first element in the tuple) is associated with multiple devices, such as Tablet, Mobile, etc. I appreciate this is specific to my use case and not always true. To be entirely fair, as a Data Scientist, 99% of the times you don't really care about which category is being dropped since that is simply your baseline. I guess in those situations when you need a specific category to be dropped, you can always build your own sorting function to pass to the key argument in sorted. What do you think? — You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub <https://github.com/scikit-learn/scikit-learn/pull/9361#discussion_r128625938>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AAEz6_FXTJlr9yn4TatzsLy6RkFc1lgfks5sP7vogaJpZM4OYxec> . --------------------[MRG] add drop_first option to OneHotEncoder <!-- Thanks for contributing a pull request! Please ensure you have taken a look at the contribution guidelines: https://github.com/scikit-learn/scikit-learn/blob/master/CONTRIBUTING.md#pull-request-checklist --> #### Reference Issues/PRs <!-- Example: Fixes #1234. See also #3456. Please use keywords (e.g., Fixes) to create link to the issues or pull requests you resolved, so that they will automatically be closed when your pull request is merged. See https://github.com/blog/1506-closing-issues-via-pull-requests --> Closes #6488 #### What does this implement/fix? Explain your changes. This PR adds a `drop_first` option to `OneHotEncoder`. Each feature is encoded into `n_unique_values - 1` columns instead of `n_unique_values` columns. The first one is dropped, resulting in all of the others being zero. #### Any other comments? This is incompatible with `handle_missing='ignore'` because the ignored missing categories result in all of the one-hot columns being zeros, which is also how the first category is treated when `drop_first=True`. So by allowing both, there would be no way to distinguish between a missing category and the first one. <!-- Please be aware that we are a loose team of volunteers so patience is necessary; assistance handling other issues is very welcome. We value all user contributions, no matter how minor they are. If we are slow to review, either the pull request needs some benchmarking, tinkering, convincing, etc. or more likely the reviewers are simply busy. In either case, we ask for your understanding during the review process. For more information, see our FAQ on this topic: http://scikit-learn.org/dev/faq.html#why-is-my-pull-request-not-getting-any-attention. Thanks for contributing! --> ---------- -------------------- </issues>	66cc1c7342f7f0cc0dc57fb6d56053fc46c8e5f0

pvlib__pvlib-python-784

784

pvlib/pvlib-python

0.6

e94d9238a8c6eacee57e03f4a4fa267673f941f3

2019-10-02T23:52:22Z

diff --git a/docs/sphinx/source/api.rst b/docs/sphinx/source/api.rst index c37bedf7df..26786d4f88 100644 --- a/docs/sphinx/source/api.rst +++ b/docs/sphinx/source/api.rst @@ -303,6 +303,7 @@ Functions for fitting PV models ivtools.fit_sde_sandia ivtools.fit_sdm_cec_sam + ivtools.fit_sdm_desoto Other ----- diff --git a/docs/sphinx/source/whatsnew/v0.7.0.rst b/docs/sphinx/source/whatsnew/v0.7.0.rst index 2b65b17a9e..fdc419ef6e 100644 --- a/docs/sphinx/source/whatsnew/v0.7.0.rst +++ b/docs/sphinx/source/whatsnew/v0.7.0.rst @@ -1,4 +1,4 @@ -.. _whatsnew_0700: +.. _whatsnew_0700: v0.7.0 (MONTH DAY, YEAR) ------------------------ @@ -111,6 +111,8 @@ Enhancements the single diode equation to an IV curve. * Add :py:func:`~pvlib.ivtools.fit_sdm_cec_sam`, a wrapper for the CEC single diode model fitting function '6parsolve' from NREL's System Advisor Model. +* Add :py:func:`~pvlib.ivtools.fit_sdm_desoto`, a method to fit the De Soto single + diode model to the typical specifications given in manufacturers datasheets. * Add `timeout` to :py:func:`pvlib.iotools.get_psm3`. Bug fixes @@ -162,4 +164,5 @@ Contributors * Anton Driesse (:ghuser:`adriesse`) * Alexander Morgan (:ghuser:`alexandermorgan`) * Miguel Sánchez de León Peque (:ghuser:`Peque`) +* Tanguy Lunel (:ghuser:`tylunel`) * Veronica Guo (:ghuser:`veronicaguo`) diff --git a/pvlib/ivtools.py b/pvlib/ivtools.py index 353a0b8a9a..4806b2ed16 100644 --- a/pvlib/ivtools.py +++ b/pvlib/ivtools.py @@ -262,6 +262,147 @@ def fit_sde_sandia(voltage, current, v_oc=None, i_sc=None, v_mp_i_mp=None, v_oc) +def fit_sdm_desoto(v_mp, i_mp, v_oc, i_sc, alpha_sc, beta_voc, + cells_in_series, EgRef=1.121, dEgdT=-0.0002677, + temp_ref=25, irrad_ref=1000, root_kwargs={}): + """ + Calculates the parameters for the De Soto single diode model using the + procedure described in [1]. This procedure has the advantage of + using common specifications given by manufacturers in the + datasheets of PV modules. + + The solution is found using the scipy.optimize.root() function, + with the corresponding default solver method 'hybr'. + No restriction is put on the fit variables, i.e. series + or shunt resistance could go negative. Nevertheless, if it happens, + check carefully the inputs and their units; alpha_sc and beta_voc are + often given in %/K in manufacturers datasheets and should be given + in A/K and V/K here. + + The parameters returned by this function can be used by + pvsystem.calcparams_desoto to calculate the values at different + irradiance and cell temperature. + + Parameters + ---------- + v_mp: float + Module voltage at the maximum-power point at reference conditions [V]. + i_mp: float + Module current at the maximum-power point at reference conditions [A]. + v_oc: float + Open-circuit voltage at reference conditions [V]. + i_sc: float + Short-circuit current at reference conditions [A]. + alpha_sc: float + The short-circuit current (i_sc) temperature coefficient of the + module [A/K]. + beta_voc: float + The open-circuit voltage (v_oc) temperature coefficient of the + module [V/K]. + cells_in_series: integer + Number of cell in the module. + EgRef: float, default 1.121 eV - value for silicon + Energy of bandgap of semi-conductor used [eV] + dEgdT: float, default -0.0002677 - value for silicon + Variation of bandgap according to temperature [eV/K] + temp_ref: float, default 25 + Reference temperature condition [C] + irrad_ref: float, default 1000 + Reference irradiance condition [W/m2] + root_kwargs: dictionary, default None + Dictionary of arguments to pass onto scipy.optimize.root() + + Returns + ------- + Tuple of the following elements: + + * Dictionary with the following elements: + I_L_ref: float + Light-generated current at reference conditions [A] + I_o_ref: float + Diode saturation current at reference conditions [A] + R_s: float + Series resistance [ohms] + R_sh_ref: float + Shunt resistance at reference conditions [ohms]. + a_ref: float + Modified ideality factor at reference conditions. + The product of the usual diode ideality factor (n, unitless), + number of cells in series (Ns), and cell thermal voltage at + specified effective irradiance and cell temperature. + alpha_sc: float + The short-circuit current (i_sc) temperature coefficient of the + module [A/K]. + EgRef: float + Energy of bandgap of semi-conductor used [eV] + dEgdT: float + Variation of bandgap according to temperature [eV/K] + irrad_ref: float + Reference irradiance condition [W/m2] + temp_ref: float + Reference temperature condition [C] + * scipy.optimize.OptimizeResult + Optimization result of scipy.optimize.root(). + See scipy.optimize.OptimizeResult for more details. + + References + ---------- + [1] W. De Soto et al., "Improvement and validation of a model for + photovoltaic array performance", Solar Energy, vol 80, pp. 78-88, + 2006. + + [2] John A Dufﬁe, William A Beckman, "Solar Engineering of Thermal + Processes", Wiley, 2013 + """ + + try: + from scipy.optimize import root + from scipy import constants + except ImportError: + raise ImportError("The fit_sdm_desoto function requires scipy.") + + # Constants + k = constants.value('Boltzmann constant in eV/K') + Tref = temp_ref + 273.15 # [K] + + # initial guesses of variables for computing convergence: + # Values are taken from [2], p753 + Rsh_0 = 100.0 + a_0 = 1.5*k*Tref*cells_in_series + IL_0 = i_sc + Io_0 = i_sc * np.exp(-v_oc/a_0) + Rs_0 = (a_0*np.log1p((IL_0-i_mp)/Io_0) - v_mp)/i_mp + # params_i : initial values vector + params_i = np.array([IL_0, Io_0, a_0, Rsh_0, Rs_0]) + + # specs of module + specs = (i_sc, v_oc, i_mp, v_mp, beta_voc, alpha_sc, EgRef, dEgdT, + Tref, k) + + # computing with system of equations described in [1] + optimize_result = root(_system_of_equations_desoto, x0=params_i, + args=(specs,), **root_kwargs) + + if optimize_result.success: + sdm_params = optimize_result.x + else: + raise RuntimeError( + 'Parameter estimation failed:\n' + optimize_result.message) + + # results + return ({'I_L_ref': sdm_params[0], + 'I_o_ref': sdm_params[1], + 'a_ref': sdm_params[2], + 'R_sh_ref': sdm_params[3], + 'R_s': sdm_params[4], + 'alpha_sc': alpha_sc, + 'EgRef': EgRef, + 'dEgdT': dEgdT, + 'irrad_ref': irrad_ref, + 'temp_ref': temp_ref}, + optimize_result) + + def _find_mp(voltage, current): """ Finds voltage and current at maximum power point. @@ -348,3 +489,69 @@ def _calculate_sde_parameters(beta0, beta1, beta3, beta4, v_mp, i_mp, v_oc): else: # I0_voc > 0 I0 = I0_voc return (IL, I0, Rsh, Rs, nNsVth) + + +def _system_of_equations_desoto(params, specs): + """Evaluates the systems of equations used to solve for the single + diode equation parameters. Function designed to be used by + scipy.optimize.root() in fit_sdm_desoto(). + + Parameters + ---------- + params: ndarray + Array with parameters of the De Soto single diode model. Must be + given in the following order: IL, Io, a, Rsh, Rs + specs: tuple + Specifications of pv module given by manufacturer. Must be given + in the following order: Isc, Voc, Imp, Vmp, beta_oc, alpha_sc + + Returns + ------- + system of equations to solve with scipy.optimize.root(). + + + References + ---------- + [1] W. De Soto et al., "Improvement and validation of a model for + photovoltaic array performance", Solar Energy, vol 80, pp. 78-88, + 2006. + + [2] John A Dufﬁe, William A Beckman, "Solar Engineering of Thermal + Processes", Wiley, 2013 + """ + + # six input known variables + Isc, Voc, Imp, Vmp, beta_oc, alpha_sc, EgRef, dEgdT, Tref, k = specs + + # five parameters vector to find + IL, Io, a, Rsh, Rs = params + + # five equation vector + y = [0, 0, 0, 0, 0] + + # 1st equation - short-circuit - eq(3) in [1] + y[0] = Isc - IL + Io * np.expm1(Isc * Rs / a) + Isc * Rs / Rsh + + # 2nd equation - open-circuit Tref - eq(4) in [1] + y[1] = -IL + Io * np.expm1(Voc / a) + Voc / Rsh + + # 3rd equation - Imp & Vmp - eq(5) in [1] + y[2] = Imp - IL + Io * np.expm1((Vmp + Imp * Rs) / a) \ + + (Vmp + Imp * Rs) / Rsh + + # 4th equation - Pmp derivated=0 - eq23.2.6 in [2] + # caution: eq(6) in [1] has a sign error + y[3] = Imp \ + - Vmp * ((Io / a) * np.exp((Vmp + Imp * Rs) / a) + 1.0 / Rsh) \ + / (1.0 + (Io * Rs / a) * np.exp((Vmp + Imp * Rs) / a) + Rs / Rsh) + + # 5th equation - open-circuit T2 - eq (4) at temperature T2 in [1] + T2 = Tref + 2 + Voc2 = (T2 - Tref) * beta_oc + Voc # eq (7) in [1] + a2 = a * T2 / Tref # eq (8) in [1] + IL2 = IL + alpha_sc * (T2 - Tref) # eq (11) in [1] + Eg2 = EgRef * (1 + dEgdT * (T2 - Tref)) # eq (10) in [1] + Io2 = Io * (T2 / Tref)**3 * np.exp(1 / k * (EgRef/Tref - Eg2/T2)) # eq (9) + y[4] = -IL2 + Io2 * np.expm1(Voc2 / a2) + Voc2 / Rsh # eq (4) at T2 + + return y

diff --git a/pvlib/test/test_ivtools.py b/pvlib/test/test_ivtools.py index d4aca050c4..6f9fdd6fec 100644 --- a/pvlib/test/test_ivtools.py +++ b/pvlib/test/test_ivtools.py @@ -102,6 +102,35 @@ def test_fit_sdm_cec_sam(get_cec_params_cansol_cs5p_220p): cells_in_series=1, temp_ref=25) +@requires_scipy +def test_fit_sdm_desoto(): + result, _ = ivtools.fit_sdm_desoto(v_mp=31.0, i_mp=8.71, v_oc=38.3, + i_sc=9.43, alpha_sc=0.005658, + beta_voc=-0.13788, + cells_in_series=60) + result_expected = {'I_L_ref': 9.45232, + 'I_o_ref': 3.22460e-10, + 'a_ref': 1.59128, + 'R_sh_ref': 125.798, + 'R_s': 0.297814, + 'alpha_sc': 0.005658, + 'EgRef': 1.121, + 'dEgdT': -0.0002677, + 'irrad_ref': 1000, + 'temp_ref': 25} + assert np.allclose(pd.Series(result), pd.Series(result_expected), + rtol=1e-4) + + +@requires_scipy +def test_fit_sdm_desoto_failure(): + with pytest.raises(RuntimeError) as exc: + ivtools.fit_sdm_desoto(v_mp=31.0, i_mp=8.71, v_oc=38.3, i_sc=9.43, + alpha_sc=0.005658, beta_voc=-0.13788, + cells_in_series=10) + assert ('Parameter estimation failed') in str(exc.value) + + @pytest.fixture def get_bad_iv_curves(): # v1, i1 produces a bad value for I0_voc

diff --git a/docs/sphinx/source/api.rst b/docs/sphinx/source/api.rst index c37bedf7df..26786d4f88 100644 --- a/docs/sphinx/source/api.rst +++ b/docs/sphinx/source/api.rst @@ -303,6 +303,7 @@ Functions for fitting PV models ivtools.fit_sde_sandia ivtools.fit_sdm_cec_sam + ivtools.fit_sdm_desoto Other ----- diff --git a/docs/sphinx/source/whatsnew/v0.7.0.rst b/docs/sphinx/source/whatsnew/v0.7.0.rst index 2b65b17a9e..fdc419ef6e 100644 --- a/docs/sphinx/source/whatsnew/v0.7.0.rst +++ b/docs/sphinx/source/whatsnew/v0.7.0.rst @@ -1,4 +1,4 @@ -.. _whatsnew_0700: +.. _whatsnew_0700: v0.7.0 (MONTH DAY, YEAR) ------------------------ @@ -111,6 +111,8 @@ Enhancements the single diode equation to an IV curve. * Add :py:func:`~pvlib.ivtools.fit_sdm_cec_sam`, a wrapper for the CEC single diode model fitting function '6parsolve' from NREL's System Advisor Model. +* Add :py:func:`~pvlib.ivtools.fit_sdm_desoto`, a method to fit the De Soto single + diode model to the typical specifications given in manufacturers datasheets. * Add `timeout` to :py:func:`pvlib.iotools.get_psm3`. Bug fixes @@ -162,4 +164,5 @@ Contributors * Anton Driesse (:ghuser:`adriesse`) * Alexander Morgan (:ghuser:`alexandermorgan`) * Miguel Sánchez de León Peque (:ghuser:`Peque`) +* Tanguy Lunel (:ghuser:`tylunel`) * Veronica Guo (:ghuser:`veronicaguo`)

[ { "components": [ { "doc": "Calculates the parameters for the De Soto single diode model using the\nprocedure described in [1]. This procedure has the advantage of\nusing common specifications given by manufacturers in the\ndatasheets of PV modules.\n\nThe solution is found using the scipy.optimiz...

[ "pvlib/test/test_ivtools.py::test_fit_sdm_desoto", "pvlib/test/test_ivtools.py::test_fit_sdm_desoto_failure" ]

[ "pvlib/test/test_ivtools.py::test_fit_sde_sandia", "pvlib/test/test_ivtools.py::test_fit_sde_sandia_bad_iv", "pvlib/test/test_ivtools.py::test_fit_sdm_cec_sam" ]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> coefficient estimation method following DeSoto(2006) - [x] I am familiar with the [contributing guidelines](http://pvlib-python.readthedocs.io/en/latest/contributing.html). - [x] Fully tested. Added and/or modified tests to ensure correct behavior for all reasonable inputs. Tests (usually) must pass on the TravisCI and Appveyor testing services. - [x] Updates entries to `docs/sphinx/source/api.rst` for API changes. - [x] Adds description and name entries in the appropriate `docs/sphinx/source/whatsnew` file for all changes. - [x] Code quality and style is sufficient. Passes LGTM and SticklerCI checks. - [x] New code is fully documented. Includes sphinx/numpydoc compliant docstrings and comments in the code where necessary. - [x] Pull request is nearly complete and ready for detailed review. Brief description of the problem and proposed solution: This function computes the 5 sdm parameters coefficients following the procedure proposed by W. De Soto et al., "Improvement and validation of a model for photovoltaic array performance", Solar Energy, vol80, pp. 78-88, 2006. In my opinion the function has the advantage to be transparent for python users and can be used with standard specifications found in manucfacturer datasheets. Please just state your interest or not in this function and, if you are interested, I will complete it so as to check all the conditions then. This is my first pull request so don't hesitate to give me any feedback you think useful, thanks ! ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pvlib/ivtools.py] (definition of fit_sdm_desoto:) def fit_sdm_desoto(v_mp, i_mp, v_oc, i_sc, alpha_sc, beta_voc, cells_in_series, EgRef=1.121, dEgdT=-0.0002677, temp_ref=25, irrad_ref=1000, root_kwargs={}): """Calculates the parameters for the De Soto single diode model using the procedure described in [1]. This procedure has the advantage of using common specifications given by manufacturers in the datasheets of PV modules. The solution is found using the scipy.optimize.root() function, with the corresponding default solver method 'hybr'. No restriction is put on the fit variables, i.e. series or shunt resistance could go negative. Nevertheless, if it happens, check carefully the inputs and their units; alpha_sc and beta_voc are often given in %/K in manufacturers datasheets and should be given in A/K and V/K here. The parameters returned by this function can be used by pvsystem.calcparams_desoto to calculate the values at different irradiance and cell temperature. Parameters ---------- v_mp: float Module voltage at the maximum-power point at reference conditions [V]. i_mp: float Module current at the maximum-power point at reference conditions [A]. v_oc: float Open-circuit voltage at reference conditions [V]. i_sc: float Short-circuit current at reference conditions [A]. alpha_sc: float The short-circuit current (i_sc) temperature coefficient of the module [A/K]. beta_voc: float The open-circuit voltage (v_oc) temperature coefficient of the module [V/K]. cells_in_series: integer Number of cell in the module. EgRef: float, default 1.121 eV - value for silicon Energy of bandgap of semi-conductor used [eV] dEgdT: float, default -0.0002677 - value for silicon Variation of bandgap according to temperature [eV/K] temp_ref: float, default 25 Reference temperature condition [C] irrad_ref: float, default 1000 Reference irradiance condition [W/m2] root_kwargs: dictionary, default None Dictionary of arguments to pass onto scipy.optimize.root() Returns ------- Tuple of the following elements: * Dictionary with the following elements: I_L_ref: float Light-generated current at reference conditions [A] I_o_ref: float Diode saturation current at reference conditions [A] R_s: float Series resistance [ohms] R_sh_ref: float Shunt resistance at reference conditions [ohms]. a_ref: float Modified ideality factor at reference conditions. The product of the usual diode ideality factor (n, unitless), number of cells in series (Ns), and cell thermal voltage at specified effective irradiance and cell temperature. alpha_sc: float The short-circuit current (i_sc) temperature coefficient of the module [A/K]. EgRef: float Energy of bandgap of semi-conductor used [eV] dEgdT: float Variation of bandgap according to temperature [eV/K] irrad_ref: float Reference irradiance condition [W/m2] temp_ref: float Reference temperature condition [C] * scipy.optimize.OptimizeResult Optimization result of scipy.optimize.root(). See scipy.optimize.OptimizeResult for more details. References ---------- [1] W. De Soto et al., "Improvement and validation of a model for photovoltaic array performance", Solar Energy, vol 80, pp. 78-88, 2006. [2] John A Dufﬁe, William A Beckman, "Solar Engineering of Thermal Processes", Wiley, 2013""" (definition of _system_of_equations_desoto:) def _system_of_equations_desoto(params, specs): """Evaluates the systems of equations used to solve for the single diode equation parameters. Function designed to be used by scipy.optimize.root() in fit_sdm_desoto(). Parameters ---------- params: ndarray Array with parameters of the De Soto single diode model. Must be given in the following order: IL, Io, a, Rsh, Rs specs: tuple Specifications of pv module given by manufacturer. Must be given in the following order: Isc, Voc, Imp, Vmp, beta_oc, alpha_sc Returns ------- system of equations to solve with scipy.optimize.root(). References ---------- [1] W. De Soto et al., "Improvement and validation of a model for photovoltaic array performance", Solar Energy, vol 80, pp. 78-88, 2006. [2] John A Dufﬁe, William A Beckman, "Solar Engineering of Thermal Processes", Wiley, 2013""" [end of new definitions in pvlib/ivtools.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

7fc595a13bcd42e3269c0806f5505ac907af9730

sympy__sympy-17677

17,677

sympy/sympy

1.5

0ace745eac76d054af75f3d578b9d567e3581a80

2019-10-01T09:21:18Z

diff --git a/sympy/combinatorics/perm_groups.py b/sympy/combinatorics/perm_groups.py index d854935efa6e..ebc41adef4b6 100644 --- a/sympy/combinatorics/perm_groups.py +++ b/sympy/combinatorics/perm_groups.py @@ -1873,6 +1873,73 @@ def is_elementary(self, p): """ return self.is_abelian and all(g.order() == p for g in self.generators) + def _eval_is_alt_sym_naive(self, only_sym=False, only_alt=False): + """A naive test using the group order.""" + if only_sym and only_alt: + raise ValueError( + "Both {} and {} cannot be set to True" + .format(only_sym, only_alt)) + + n = self.degree + sym_order = 1 + for i in range(2, n+1): + sym_order *= i + order = self.order() + + if order == sym_order: + self._is_sym = True + self._is_alt = False + if only_alt: + return False + return True + + elif 2*order == sym_order: + self._is_sym = False + self._is_alt = True + if only_sym: + return False + return True + + return False + + def _eval_is_alt_sym_monte_carlo(self, eps=0.05, perms=None): + """A test using monte-carlo algorithm. + + Parameters + ========== + + eps : float, optional + The criterion for the incorrect ``False`` return. + + perms : list[Permutation], optional + If explicitly given, it tests over the given candidats + for testing. + + If ``None``, it randomly computes ``N_eps`` and chooses + ``N_eps`` sample of the permutation from the group. + + See Also + ======== + + _check_cycles_alt_sym + """ + if perms is None: + n = self.degree + if n < 17: + c_n = 0.34 + else: + c_n = 0.57 + d_n = (c_n*log(2))/log(n) + N_eps = int(-log(eps)/d_n) + + perms = (self.random_pr() for i in range(N_eps)) + return self._eval_is_alt_sym_monte_carlo(perms=perms) + + for perm in perms: + if _check_cycles_alt_sym(perm): + return True + return False + def is_alt_sym(self, eps=0.05, _random_prec=None): r"""Monte Carlo test for the symmetric/alternating group for degrees >= 8. @@ -1913,42 +1980,25 @@ def is_alt_sym(self, eps=0.05, _random_prec=None): _check_cycles_alt_sym """ - if _random_prec is None: - if self._is_sym or self._is_alt: - return True - n = self.degree - if n < 8: - sym_order = 1 - for i in range(2, n+1): - sym_order *= i - order = self.order() - if order == sym_order: - self._is_sym = True - return True - elif 2*order == sym_order: - self._is_alt = True - return True - return False - if not self.is_transitive(): - return False - if n < 17: - c_n = 0.34 - else: - c_n = 0.57 - d_n = (c_n*log(2))/log(n) - N_eps = int(-log(eps)/d_n) - for i in range(N_eps): - perm = self.random_pr() - if _check_cycles_alt_sym(perm): - return True - return False - else: - for i in range(_random_prec['N_eps']): - perm = _random_prec[i] - if _check_cycles_alt_sym(perm): - return True + if _random_prec is not None: + N_eps = _random_prec['N_eps'] + perms= (_random_prec[i] for i in range(N_eps)) + return self._eval_is_alt_sym_monte_carlo(perms=perms) + + if self._is_sym or self._is_alt: + return True + if self._is_sym is False and self._is_alt is False: return False + n = self.degree + if n < 8: + return self._eval_is_alt_sym_naive() + elif self.is_transitive(): + return self._eval_is_alt_sym_monte_carlo(eps=eps) + + self._is_sym, self._is_alt = False, False + return False + @property def is_nilpotent(self): """Test if the group is nilpotent. @@ -2820,6 +2870,123 @@ def index(self, H): if H.is_subgroup(self): return self.order()//H.order() + @property + def is_symmetric(self): + """Return ``True`` if the group is symmetric. + + Examples + ======== + + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> g = SymmetricGroup(5) + >>> g.is_symmetric + True + + >>> from sympy.combinatorics import Permutation, PermutationGroup + >>> g = PermutationGroup( + ... Permutation(0, 1, 2, 3, 4), + ... Permutation(2, 3)) + >>> g.is_symmetric + True + + Notes + ===== + + This uses a naive test involving the computation of the full + group order. + If you need more quicker taxonomy for large groups, you can use + :meth:`PermutationGroup.is_alt_sym`. + However, :meth:`PermutationGroup.is_alt_sym` may not be accurate + and is not able to distinguish between an alternating group and + a symmetric group. + + See Also + ======== + + is_alt_sym + """ + _is_sym = self._is_sym + if _is_sym is not None: + return _is_sym + + n = self.degree + if n >= 8: + if self.is_transitive(): + _is_alt_sym = self._eval_is_alt_sym_monte_carlo() + if _is_alt_sym: + if any(g.is_odd for g in self.generators): + self._is_sym, self._is_alt = True, False + return True + + self._is_sym, self._is_alt = False, True + return False + + return self._eval_is_alt_sym_naive(only_sym=True) + + self._is_sym, self._is_alt = False, False + return False + + return self._eval_is_alt_sym_naive(only_sym=True) + + + @property + def is_alternating(self): + """Return ``True`` if the group is alternating. + + Examples + ======== + + >>> from sympy.combinatorics.named_groups import AlternatingGroup + >>> g = AlternatingGroup(5) + >>> g.is_alternating + True + + >>> from sympy.combinatorics import Permutation, PermutationGroup + >>> g = PermutationGroup( + ... Permutation(0, 1, 2, 3, 4), + ... Permutation(2, 3, 4)) + >>> g.is_alternating + True + + Notes + ===== + + This uses a naive test involving the computation of the full + group order. + If you need more quicker taxonomy for large groups, you can use + :meth:`PermutationGroup.is_alt_sym`. + However, :meth:`PermutationGroup.is_alt_sym` may not be accurate + and is not able to distinguish between an alternating group and + a symmetric group. + + See Also + ======== + + is_alt_sym + """ + _is_alt = self._is_alt + if _is_alt is not None: + return _is_alt + + n = self.degree + if n >= 8: + if self.is_transitive(): + _is_alt_sym = self._eval_is_alt_sym_monte_carlo() + if _is_alt_sym: + if all(g.is_even for g in self.generators): + self._is_sym, self._is_alt = False, True + return True + + self._is_sym, self._is_alt = True, False + return False + + return self._eval_is_alt_sym_naive(only_alt=True) + + self._is_sym, self._is_alt = False, False + return False + + return self._eval_is_alt_sym_naive(only_alt=True) + @property def is_cyclic(self): """

diff --git a/sympy/combinatorics/tests/test_perm_groups.py b/sympy/combinatorics/tests/test_perm_groups.py index da2922c845a7..7426a062651d 100644 --- a/sympy/combinatorics/tests/test_perm_groups.py +++ b/sympy/combinatorics/tests/test_perm_groups.py @@ -437,7 +437,15 @@ def test_random_pr(): def test_is_alt_sym(): G = DihedralGroup(10) assert G.is_alt_sym() is False + assert G._eval_is_alt_sym_naive() is False + assert G._eval_is_alt_sym_naive(only_alt=True) is False + assert G._eval_is_alt_sym_naive(only_sym=True) is False + S = SymmetricGroup(10) + assert S._eval_is_alt_sym_naive() is True + assert S._eval_is_alt_sym_naive(only_alt=True) is False + assert S._eval_is_alt_sym_naive(only_sym=True) is True + N_eps = 10 _random_prec = {'N_eps': N_eps, 0: Permutation([[2], [1, 4], [0, 6, 7, 8, 9, 3, 5]]), @@ -451,7 +459,12 @@ def test_is_alt_sym(): 8: Permutation([[1, 5, 6, 3], [0, 2, 7, 8, 4, 9]]), 9: Permutation([[8], [6, 7], [2, 3, 4, 5], [0, 1, 9]])} assert S.is_alt_sym(_random_prec=_random_prec) is True + A = AlternatingGroup(10) + assert A._eval_is_alt_sym_naive() is True + assert A._eval_is_alt_sym_naive(only_alt=True) is True + assert A._eval_is_alt_sym_naive(only_sym=True) is False + _random_prec = {'N_eps': N_eps, 0: Permutation([[1, 6, 4, 2, 7, 8, 5, 9, 3], [0]]), 1: Permutation([[1], [0, 5, 8, 4, 9, 2, 3, 6, 7]]), @@ -465,6 +478,23 @@ def test_is_alt_sym(): 9: Permutation([[4, 9, 6], [3, 8], [1, 2], [0, 5, 7]])} assert A.is_alt_sym(_random_prec=_random_prec) is False + G = PermutationGroup( + Permutation(1, 3, size=8)(0, 2, 4, 6), + Permutation(5, 7, size=8)(0, 2, 4, 6)) + assert G.is_alt_sym() is False + + # Tests for monte-carlo c_n parameter setting, and which guarantees + # to give False. + G = DihedralGroup(10) + assert G._eval_is_alt_sym_monte_carlo() is False + G = DihedralGroup(20) + assert G._eval_is_alt_sym_monte_carlo() is False + + # A dry-running test to check if it looks up for the updated cache. + G = DihedralGroup(6) + G.is_alt_sym() + assert G.is_alt_sym() == False + def test_minimal_block(): D = DihedralGroup(6) @@ -1013,3 +1043,17 @@ def test_composition_series(): assert is_isomorphic(series[1], CyclicGroup(4)) assert is_isomorphic(series[2], CyclicGroup(2)) assert series[3].is_trivial + + +def test_is_symmetric(): + a = Permutation(0, 1, 2) + b = Permutation(0, 1, size=3) + assert PermutationGroup(a, b).is_symmetric == True + + a = Permutation(0, 2, 1) + b = Permutation(1, 2, size=3) + assert PermutationGroup(a, b).is_symmetric == True + + a = Permutation(0, 1, 2, 3) + b = Permutation(0, 3)(1, 2) + assert PermutationGroup(a, b).is_symmetric == False

[ { "components": [ { "doc": "A naive test using the group order.", "lines": [ 1876, 1903 ], "name": "PermutationGroup._eval_is_alt_sym_naive", "signature": "def _eval_is_alt_sym_naive(self, only_sym=False, only_alt=False):", "type": "funct...

[ "test_is_alt_sym" ]

[ "test_has", "test_generate", "test_order", "test_equality", "test_stabilizer", "test_center", "test_centralizer", "test_coset_rank", "test_coset_factor", "test_orbits", "test_is_normal", "test_eq", "test_derived_subgroup", "test_is_solvable", "test_rubik1", "test_direct_product", "te...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add is_symmetric for permutation groups  #### References to other Issues or PRs  #### Brief description of what is fixed or changed I think that `is_symmetric` predicate is missing even if `_is_sym` cache is used in permutation groups. I've used a naive test that the symmetric group is the largest permutation group that can be created from a base set of cardinality `n`, and have an order of `n!`. #### Other comments I think that permutation group is using custom cache for assumptions. But if there is a way to directly manipulate the global LRU cache or assumptions0 cache if some predicates are revealed during the computation, it may have to use those. #### Release Notes   - combinatorics - Added a new predicate `is_symmetric` to test out if a permutation group is a symmetric group. - Added a new predicate `is_alternating` to test out if a permutation group is a alternating group.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/combinatorics/perm_groups.py] (definition of PermutationGroup._eval_is_alt_sym_naive:) def _eval_is_alt_sym_naive(self, only_sym=False, only_alt=False): """A naive test using the group order.""" (definition of PermutationGroup._eval_is_alt_sym_monte_carlo:) def _eval_is_alt_sym_monte_carlo(self, eps=0.05, perms=None): """A test using monte-carlo algorithm. Parameters ========== eps : float, optional The criterion for the incorrect ``False`` return. perms : list[Permutation], optional If explicitly given, it tests over the given candidats for testing. If ``None``, it randomly computes ``N_eps`` and chooses ``N_eps`` sample of the permutation from the group. See Also ======== _check_cycles_alt_sym""" (definition of PermutationGroup.is_symmetric:) def is_symmetric(self): """Return ``True`` if the group is symmetric. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> g = SymmetricGroup(5) >>> g.is_symmetric True >>> from sympy.combinatorics import Permutation, PermutationGroup >>> g = PermutationGroup( ... Permutation(0, 1, 2, 3, 4), ... Permutation(2, 3)) >>> g.is_symmetric True Notes ===== This uses a naive test involving the computation of the full group order. If you need more quicker taxonomy for large groups, you can use :meth:`PermutationGroup.is_alt_sym`. However, :meth:`PermutationGroup.is_alt_sym` may not be accurate and is not able to distinguish between an alternating group and a symmetric group. See Also ======== is_alt_sym""" (definition of PermutationGroup.is_alternating:) def is_alternating(self): """Return ``True`` if the group is alternating. Examples ======== >>> from sympy.combinatorics.named_groups import AlternatingGroup >>> g = AlternatingGroup(5) >>> g.is_alternating True >>> from sympy.combinatorics import Permutation, PermutationGroup >>> g = PermutationGroup( ... Permutation(0, 1, 2, 3, 4), ... Permutation(2, 3, 4)) >>> g.is_alternating True Notes ===== This uses a naive test involving the computation of the full group order. If you need more quicker taxonomy for large groups, you can use :meth:`PermutationGroup.is_alt_sym`. However, :meth:`PermutationGroup.is_alt_sym` may not be accurate and is not able to distinguish between an alternating group and a symmetric group. See Also ======== is_alt_sym""" [end of new definitions in sympy/combinatorics/perm_groups.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

scikit-learn__scikit-learn-15010

15,010

scikit-learn/scikit-learn

0.22

a91bae74aaca4979f5d927db327654b1d8e3ae58

2019-09-18T12:45:15Z

diff --git a/doc/whats_new/v0.22.rst b/doc/whats_new/v0.22.rst index 4ae47980a51da..8c90650c3a1f0 100644 --- a/doc/whats_new/v0.22.rst +++ b/doc/whats_new/v0.22.rst @@ -307,6 +307,10 @@ Changelog k-Nearest Neighbors. :issue:`12852` by :user:`Ashim Bhattarai <ashimb9>` and `Thomas Fan`_. +- |Enhancement| Adds parameter `add_indicator` to :class:`imputer.KNNImputer` + to get indicator of missing data. + :pr:`15010` by :user:`Guillaume Lemaitre <glemaitre>`. + - |Feature| :class:`impute.IterativeImputer` has new `skip_compute` flag that is False by default, which, when True, will skip computation on features that have no missing values during the fit phase. :issue:`13773` by diff --git a/sklearn/impute/_base.py b/sklearn/impute/_base.py index 3c0ce72cb2689..2ad49833641dc 100644 --- a/sklearn/impute/_base.py +++ b/sklearn/impute/_base.py @@ -2,10 +2,8 @@ # Sergey Feldman <sergeyfeldman@gmail.com> # License: BSD 3 clause -from __future__ import division - -import warnings import numbers +import warnings import numpy as np import numpy.ma as ma @@ -64,7 +62,60 @@ def _most_frequent(array, extra_value, n_repeat): return extra_value -class SimpleImputer(TransformerMixin, BaseEstimator): +class _BaseImputer(TransformerMixin, BaseEstimator): + """Base class for all imputers. + + It adds automatically support for `add_indicator`. + """ + + def __init__(self, missing_values=np.nan, add_indicator=False): + self.missing_values = missing_values + self.add_indicator = add_indicator + + def _fit_indicator(self, X): + """Fit a MissingIndicator.""" + if self.add_indicator: + self.indicator_ = MissingIndicator( + missing_values=self.missing_values, error_on_new=False + ) + self.indicator_.fit(X) + else: + self.indicator_ = None + + def _transform_indicator(self, X): + """Compute the indicator mask.' + + Note that X must be the original data as passed to the imputer before + any imputation, since imputation may be done inplace in some cases. + """ + if self.add_indicator: + if not hasattr(self, 'indicator_'): + raise ValueError( + "Make sure to call _fit_indicator before " + "_transform_indicator" + ) + return self.indicator_.transform(X) + + def _concatenate_indicator(self, X_imputed, X_indicator): + """Concatenate indicator mask with the imputed data.""" + if not self.add_indicator: + return X_imputed + + hstack = sparse.hstack if sparse.issparse(X_imputed) else np.hstack + if X_indicator is None: + raise ValueError( + "Data from the missing indicator are not provided. Call " + "_fit_indicator and _transform_indicator in the imputer " + "implementation." + ) + + return hstack((X_imputed, X_indicator)) + + def _more_tags(self): + return {'allow_nan': is_scalar_nan(self.missing_values)} + + +class SimpleImputer(_BaseImputer): """Imputation transformer for completing missing values. Read more in the :ref:`User Guide <impute>`. @@ -153,12 +204,14 @@ class SimpleImputer(TransformerMixin, BaseEstimator): """ def __init__(self, missing_values=np.nan, strategy="mean", fill_value=None, verbose=0, copy=True, add_indicator=False): - self.missing_values = missing_values + super().__init__( + missing_values=missing_values, + add_indicator=add_indicator + ) self.strategy = strategy self.fill_value = fill_value self.verbose = verbose self.copy = copy - self.add_indicator = add_indicator def _validate_input(self, X): allowed_strategies = ["mean", "median", "most_frequent", "constant"] @@ -213,6 +266,7 @@ def fit(self, X, y=None): self : SimpleImputer """ X = self._validate_input(X) + super()._fit_indicator(X) # default fill_value is 0 for numerical input and "missing_value" # otherwise @@ -249,14 +303,6 @@ def fit(self, X, y=None): self.strategy, self.missing_values, fill_value) - - if self.add_indicator: - self.indicator_ = MissingIndicator( - missing_values=self.missing_values, error_on_new=False) - self.indicator_.fit(X) - else: - self.indicator_ = None - return self def _sparse_fit(self, X, strategy, missing_values, fill_value): @@ -358,6 +404,7 @@ def transform(self, X): check_is_fitted(self) X = self._validate_input(X) + X_indicator = super()._transform_indicator(X) statistics = self.statistics_ @@ -365,9 +412,6 @@ def transform(self, X): raise ValueError("X has %d features per sample, expected %d" % (X.shape[1], self.statistics_.shape[0])) - if self.add_indicator: - X_trans_indicator = self.indicator_.transform(X) - # Delete the invalid columns if strategy is not constant if self.strategy == "constant": valid_statistics = statistics @@ -393,8 +437,9 @@ def transform(self, X): "array instead.") else: mask = _get_mask(X.data, self.missing_values) - indexes = np.repeat(np.arange(len(X.indptr) - 1, dtype=np.int), - np.diff(X.indptr))[mask] + indexes = np.repeat( + np.arange(len(X.indptr) - 1, dtype=np.int), + np.diff(X.indptr))[mask] X.data[mask] = valid_statistics[indexes].astype(X.dtype, copy=False) @@ -406,14 +451,7 @@ def transform(self, X): X[coordinates] = values - if self.add_indicator: - hstack = sparse.hstack if sparse.issparse(X) else np.hstack - X = hstack((X, X_trans_indicator)) - - return X - - def _more_tags(self): - return {'allow_nan': True} + return super()._concatenate_indicator(X, X_indicator) class MissingIndicator(TransformerMixin, BaseEstimator): diff --git a/sklearn/impute/_iterative.py b/sklearn/impute/_iterative.py index d797fca2c5e87..fb0045284cf87 100644 --- a/sklearn/impute/_iterative.py +++ b/sklearn/impute/_iterative.py @@ -8,7 +8,7 @@ from scipy import stats import numpy as np -from ..base import clone, BaseEstimator, TransformerMixin +from ..base import clone from ..exceptions import ConvergenceWarning from ..preprocessing import normalize from ..utils import check_array, check_random_state, _safe_indexing @@ -16,8 +16,9 @@ from ..utils import is_scalar_nan from ..utils._mask import _get_mask -from ._base import (MissingIndicator, SimpleImputer, - _check_inputs_dtype) +from ._base import _BaseImputer +from ._base import SimpleImputer +from ._base import _check_inputs_dtype _ImputerTriplet = namedtuple('_ImputerTriplet', ['feat_idx', @@ -25,7 +26,7 @@ 'estimator']) -class IterativeImputer(TransformerMixin, BaseEstimator): +class IterativeImputer(_BaseImputer): """Multivariate imputer that estimates each feature from all the others. A strategy for imputing missing values by modeling each feature with @@ -219,9 +220,12 @@ def __init__(self, verbose=0, random_state=None, add_indicator=False): + super().__init__( + missing_values=missing_values, + add_indicator=add_indicator + ) self.estimator = estimator - self.missing_values = missing_values self.sample_posterior = sample_posterior self.max_iter = max_iter self.tol = tol @@ -233,7 +237,6 @@ def __init__(self, self.max_value = max_value self.verbose = verbose self.random_state = random_state - self.add_indicator = add_indicator def _impute_one_feature(self, X_filled, @@ -302,7 +305,7 @@ def _impute_one_feature(self, # get posterior samples if there is at least one missing value X_test = _safe_indexing(X_filled[:, neighbor_feat_idx], - missing_row_mask) + missing_row_mask) if self.sample_posterior: mus, sigmas = estimator.predict(X_test, return_std=True) imputed_values = np.zeros(mus.shape, dtype=X_filled.dtype) @@ -505,8 +508,9 @@ def _initial_imputation(self, X): mask_missing_values = _get_mask(X, self.missing_values) if self.initial_imputer_ is None: self.initial_imputer_ = SimpleImputer( - missing_values=self.missing_values, - strategy=self.initial_strategy) + missing_values=self.missing_values, + strategy=self.initial_strategy + ) X_filled = self.initial_imputer_.fit_transform(X) else: X_filled = self.initial_imputer_.transform(X) @@ -532,7 +536,7 @@ def fit_transform(self, X, y=None): Returns ------- Xt : array-like, shape (n_samples, n_features) - The imputed input data. + The imputed input data. """ self.random_state_ = getattr(self, "random_state_", check_random_state(self.random_state)) @@ -548,37 +552,32 @@ def fit_transform(self, X, y=None): .format(self.tol) ) - if self.add_indicator: - self.indicator_ = MissingIndicator( - missing_values=self.missing_values, error_on_new=False) - X_trans_indicator = self.indicator_.fit_transform(X) - else: - self.indicator_ = None - if self.estimator is None: from ..linear_model import BayesianRidge self._estimator = BayesianRidge() else: self._estimator = clone(self.estimator) - self.imputation_sequence_ = [] - if hasattr(self._estimator, 'random_state'): self._estimator.random_state = self.random_state_ + self.imputation_sequence_ = [] + self._min_value = -np.inf if self.min_value is None else self.min_value self._max_value = np.inf if self.max_value is None else self.max_value self.initial_imputer_ = None + super()._fit_indicator(X) + X_indicator = super()._transform_indicator(X) X, Xt, mask_missing_values = self._initial_imputation(X) if self.max_iter == 0 or np.all(mask_missing_values): self.n_iter_ = 0 - return Xt + return super()._concatenate_indicator(Xt, X_indicator) # Edge case: a single feature. We return the initial ... if Xt.shape[1] == 1: self.n_iter_ = 0 - return Xt + return super()._concatenate_indicator(Xt, X_indicator) # order in which to impute # note this is probably too slow for large feature data (d > 100000) @@ -596,7 +595,9 @@ def fit_transform(self, X, y=None): start_t = time() if not self.sample_posterior: Xt_previous = Xt.copy() - normalized_tol = self.tol * np.max(np.abs(X[~mask_missing_values])) + normalized_tol = self.tol * np.max( + np.abs(X[~mask_missing_values]) + ) for self.n_iter_ in range(1, self.max_iter + 1): if self.imputation_order == 'random': ordered_idx = self._get_ordered_idx(mask_missing_values) @@ -624,7 +625,7 @@ def fit_transform(self, X, y=None): if self.verbose > 0: print('[IterativeImputer] ' 'Change: {}, scaled tolerance: {} '.format( - inf_norm, normalized_tol)) + inf_norm, normalized_tol)) if inf_norm < normalized_tol: if self.verbose > 0: print('[IterativeImputer] Early stopping criterion ' @@ -636,10 +637,7 @@ def fit_transform(self, X, y=None): warnings.warn("[IterativeImputer] Early stopping criterion not" " reached.", ConvergenceWarning) Xt[~mask_missing_values] = X[~mask_missing_values] - - if self.add_indicator: - Xt = np.hstack((Xt, X_trans_indicator)) - return Xt + return super()._concatenate_indicator(Xt, X_indicator) def transform(self, X): """Imputes all missing values in X. @@ -659,13 +657,11 @@ def transform(self, X): """ check_is_fitted(self) - if self.add_indicator: - X_trans_indicator = self.indicator_.transform(X) - + X_indicator = super()._transform_indicator(X) X, Xt, mask_missing_values = self._initial_imputation(X) if self.n_iter_ == 0 or np.all(mask_missing_values): - return Xt + return super()._concatenate_indicator(Xt, X_indicator) imputations_per_round = len(self.imputation_sequence_) // self.n_iter_ i_rnd = 0 @@ -691,9 +687,7 @@ def transform(self, X): Xt[~mask_missing_values] = X[~mask_missing_values] - if self.add_indicator: - Xt = np.hstack((Xt, X_trans_indicator)) - return Xt + return super()._concatenate_indicator(Xt, X_indicator) def fit(self, X, y=None): """Fits the imputer on X and return self. @@ -713,6 +707,3 @@ def fit(self, X, y=None): """ self.fit_transform(X) return self - - def _more_tags(self): - return {'allow_nan': True} diff --git a/sklearn/impute/_knn.py b/sklearn/impute/_knn.py index 15380ac18e3cf..bc8add0bf7a9b 100644 --- a/sklearn/impute/_knn.py +++ b/sklearn/impute/_knn.py @@ -1,6 +1,6 @@ import numpy as np -from ..base import BaseEstimator, TransformerMixin +from ._base import _BaseImputer from ..utils.validation import FLOAT_DTYPES from ..metrics import pairwise_distances from ..metrics.pairwise import _NAN_METRICS @@ -12,7 +12,7 @@ from ..utils.validation import check_is_fitted -class KNNImputer(TransformerMixin, BaseEstimator): +class KNNImputer(_BaseImputer): """Imputation for completing missing values using k-Nearest Neighbors. Each sample's missing values are imputed using the mean value from @@ -32,7 +32,7 @@ class KNNImputer(TransformerMixin, BaseEstimator): n_neighbors : int, default=5 Number of neighboring samples to use for imputation. - weights : str or callable, default='uniform' + weights : {'uniform', 'distance'} or callable, default='uniform' Weight function used in prediction. Possible values: - 'uniform' : uniform weights. All points in each neighborhood are @@ -44,7 +44,7 @@ class KNNImputer(TransformerMixin, BaseEstimator): array of distances, and returns an array of the same shape containing the weights. - metric : str or callable, default='nan_euclidean' + metric : {'nan_euclidean'} or callable, default='nan_euclidean' Distance metric for searching neighbors. Possible values: - 'nan_euclidean' @@ -53,10 +53,24 @@ class KNNImputer(TransformerMixin, BaseEstimator): accepts two arrays, X and Y, and a `missing_values` keyword in `kwds` and returns a scalar distance value. - copy : boolean, default=True + copy : bool, default=True If True, a copy of X will be created. If False, imputation will be done in-place whenever possible. + add_indicator : bool, default=False + If True, a :class:`MissingIndicator` transform will stack onto the + output of the imputer's transform. This allows a predictive estimator + to account for missingness despite imputation. If a feature has no + missing values at fit/train time, the feature won't appear on the + missing indicator even if there are missing values at transform/test + time. + + Attributes + ---------- + indicator_ : :class:`sklearn.impute.MissingIndicator` + Indicator used to add binary indicators for missing values. + ``None`` if add_indicator is False. + References ---------- * Olga Troyanskaya, Michael Cantor, Gavin Sherlock, Pat Brown, Trevor @@ -78,9 +92,12 @@ class KNNImputer(TransformerMixin, BaseEstimator): """ def __init__(self, missing_values=np.nan, n_neighbors=5, - weights="uniform", metric="nan_euclidean", copy=True): - - self.missing_values = missing_values + weights="uniform", metric="nan_euclidean", copy=True, + add_indicator=False): + super().__init__( + missing_values=missing_values, + add_indicator=add_indicator + ) self.n_neighbors = n_neighbors self.weights = weights self.metric = metric @@ -145,7 +162,6 @@ def fit(self, X, y=None): ------- self : object """ - # Check data integrity and calling arguments if not is_scalar_nan(self.missing_values): force_all_finite = True @@ -160,11 +176,11 @@ def fit(self, X, y=None): X = check_array(X, accept_sparse=False, dtype=FLOAT_DTYPES, force_all_finite=force_all_finite, copy=self.copy) + super()._fit_indicator(X) _check_weights(self.weights) self._fit_X = X self._mask_fit_X = _get_mask(self._fit_X, self.missing_values) - return self def transform(self, X): @@ -189,6 +205,7 @@ def transform(self, X): force_all_finite = "allow-nan" X = check_array(X, accept_sparse=False, dtype=FLOAT_DTYPES, force_all_finite=force_all_finite, copy=self.copy) + X_indicator = super()._transform_indicator(X) if X.shape[1] != self._fit_X.shape[1]: raise ValueError("Incompatible dimension between the fitted " @@ -237,7 +254,7 @@ def transform(self, X): # distances for samples that needed imputation for column dist_subset = (dist[dist_idx_map[receivers_idx]] - [:, potential_donors_idx]) + [:, potential_donors_idx]) # receivers with all nan distances impute with mean all_nan_dist_mask = np.isnan(dist_subset).all(axis=1) @@ -255,7 +272,7 @@ def transform(self, X): # receivers with at least one defined distance receivers_idx = receivers_idx[~all_nan_dist_mask] dist_subset = (dist[dist_idx_map[receivers_idx]] - [:, potential_donors_idx]) + [:, potential_donors_idx]) n_neighbors = min(self.n_neighbors, len(potential_donors_idx)) value = self._calc_impute(dist_subset, n_neighbors, @@ -263,7 +280,4 @@ def transform(self, X): mask_fit_X[potential_donors_idx, col]) X[receivers_idx, col] = value - return X[:, valid_idx] - - def _more_tags(self): - return {'allow_nan': is_scalar_nan(self.missing_values)} + return super()._concatenate_indicator(X[:, valid_idx], X_indicator)

diff --git a/sklearn/impute/tests/test_base.py b/sklearn/impute/tests/test_base.py new file mode 100644 index 0000000000000..37866943a727a --- /dev/null +++ b/sklearn/impute/tests/test_base.py @@ -0,0 +1,48 @@ +import pytest + +import numpy as np + +from sklearn.impute._base import _BaseImputer + + +@pytest.fixture +def data(): + X = np.random.randn(10, 2) + X[::2] = np.nan + return X + + +class NoFitIndicatorImputer(_BaseImputer): + def fit(self, X, y=None): + return self + + def transform(self, X, y=None): + return self._concatenate_indicator(X, self._transform_indicator(X)) + + +class NoTransformIndicatorImputer(_BaseImputer): + def fit(self, X, y=None): + super()._fit_indicator(X) + return self + + def transform(self, X, y=None): + return self._concatenate_indicator(X, None) + + +def test_base_imputer_not_fit(data): + imputer = NoFitIndicatorImputer(add_indicator=True) + err_msg = "Make sure to call _fit_indicator before _transform_indicator" + with pytest.raises(ValueError, match=err_msg): + imputer.fit(data).transform(data) + with pytest.raises(ValueError, match=err_msg): + imputer.fit_transform(data) + + +def test_base_imputer_not_transform(data): + imputer = NoTransformIndicatorImputer(add_indicator=True) + err_msg = ("Call _fit_indicator and _transform_indicator in the " + "imputer implementation") + with pytest.raises(ValueError, match=err_msg): + imputer.fit(data).transform(data) + with pytest.raises(ValueError, match=err_msg): + imputer.fit_transform(data) diff --git a/sklearn/impute/tests/test_common.py b/sklearn/impute/tests/test_common.py new file mode 100644 index 0000000000000..d4fc457bf6c28 --- /dev/null +++ b/sklearn/impute/tests/test_common.py @@ -0,0 +1,86 @@ +import pytest + +import numpy as np +from scipy import sparse + +from sklearn.utils.testing import assert_allclose +from sklearn.utils.testing import assert_allclose_dense_sparse +from sklearn.utils.testing import assert_array_equal + +from sklearn.experimental import enable_iterative_imputer # noqa + +from sklearn.impute import IterativeImputer +from sklearn.impute import KNNImputer +from sklearn.impute import SimpleImputer + + +IMPUTERS = [IterativeImputer(), KNNImputer(), SimpleImputer()] +SPARSE_IMPUTERS = [SimpleImputer()] + + +# ConvergenceWarning will be raised by the IterativeImputer +@pytest.mark.filterwarnings("ignore::sklearn.exceptions.ConvergenceWarning") +@pytest.mark.parametrize("imputer", IMPUTERS) +def test_imputation_missing_value_in_test_array(imputer): + # [Non Regression Test for issue #13968] Missing value in test set should + # not throw an error and return a finite dataset + train = [[1], [2]] + test = [[3], [np.nan]] + imputer.set_params(add_indicator=True) + imputer.fit(train).transform(test) + + +# ConvergenceWarning will be raised by the IterativeImputer +@pytest.mark.filterwarnings("ignore::sklearn.exceptions.ConvergenceWarning") +@pytest.mark.parametrize("marker", [np.nan, -1, 0]) +@pytest.mark.parametrize("imputer", IMPUTERS) +def test_imputers_add_indicator(marker, imputer): + X = np.array([ + [marker, 1, 5, marker, 1], + [2, marker, 1, marker, 2], + [6, 3, marker, marker, 3], + [1, 2, 9, marker, 4] + ]) + X_true_indicator = np.array([ + [1., 0., 0., 1.], + [0., 1., 0., 1.], + [0., 0., 1., 1.], + [0., 0., 0., 1.] + ]) + imputer.set_params(missing_values=marker, add_indicator=True) + + X_trans = imputer.fit_transform(X) + assert_allclose(X_trans[:, -4:], X_true_indicator) + assert_array_equal(imputer.indicator_.features_, np.array([0, 1, 2, 3])) + + imputer.set_params(add_indicator=False) + X_trans_no_indicator = imputer.fit_transform(X) + assert_allclose(X_trans[:, :-4], X_trans_no_indicator) + + +# ConvergenceWarning will be raised by the IterativeImputer +@pytest.mark.filterwarnings("ignore::sklearn.exceptions.ConvergenceWarning") +@pytest.mark.parametrize("marker", [np.nan, -1]) +@pytest.mark.parametrize("imputer", SPARSE_IMPUTERS) +def test_imputers_add_indicator_sparse(imputer, marker): + X = sparse.csr_matrix([ + [marker, 1, 5, marker, 1], + [2, marker, 1, marker, 2], + [6, 3, marker, marker, 3], + [1, 2, 9, marker, 4] + ]) + X_true_indicator = sparse.csr_matrix([ + [1., 0., 0., 1.], + [0., 1., 0., 1.], + [0., 0., 1., 1.], + [0., 0., 0., 1.] + ]) + imputer.set_params(missing_values=marker, add_indicator=True) + + X_trans = imputer.fit_transform(X) + assert_allclose_dense_sparse(X_trans[:, -4:], X_true_indicator) + assert_array_equal(imputer.indicator_.features_, np.array([0, 1, 2, 3])) + + imputer.set_params(add_indicator=False) + X_trans_no_indicator = imputer.fit_transform(X) + assert_allclose_dense_sparse(X_trans[:, :-4], X_trans_no_indicator) diff --git a/sklearn/impute/tests/test_impute.py b/sklearn/impute/tests/test_impute.py index c3c8b4cc329cb..6ba49c2dc9e50 100644 --- a/sklearn/impute/tests/test_impute.py +++ b/sklearn/impute/tests/test_impute.py @@ -462,16 +462,6 @@ def test_imputation_constant_pandas(dtype): assert_array_equal(X_trans, X_true) -@pytest.mark.parametrize('Imputer', (SimpleImputer, IterativeImputer)) -def test_imputation_missing_value_in_test_array(Imputer): - # [Non Regression Test for issue #13968] Missing value in test set should - # not throw an error and return a finite dataset - train = [[1], [2]] - test = [[3], [np.nan]] - imputer = Imputer(add_indicator=True) - imputer.fit(train).transform(test) - - @pytest.mark.parametrize("X", [[[1], [2]], [[1], [np.nan]]]) def test_iterative_imputer_one_feature(X): # check we exit early when there is a single feature @@ -1243,32 +1233,6 @@ def test_missing_indicator_sparse_no_explicit_zeros(): assert Xt.getnnz() == Xt.sum() -@pytest.mark.parametrize("marker", [np.nan, -1, 0]) -@pytest.mark.parametrize("imputer_constructor", - [SimpleImputer, IterativeImputer]) -def test_imputers_add_indicator(marker, imputer_constructor): - X = np.array([ - [marker, 1, 5, marker, 1], - [2, marker, 1, marker, 2], - [6, 3, marker, marker, 3], - [1, 2, 9, marker, 4] - ]) - X_true_indicator = np.array([ - [1., 0., 0., 1.], - [0., 1., 0., 1.], - [0., 0., 1., 1.], - [0., 0., 0., 1.] - ]) - imputer = imputer_constructor(missing_values=marker, - add_indicator=True) - - X_trans = imputer.fit(X).transform(X) - # The test is for testing the indicator, - # that's why we're looking at the last 4 columns only. - assert_allclose(X_trans[:, -4:], X_true_indicator) - assert_array_equal(imputer.indicator_.features_, np.array([0, 1, 2, 3])) - - @pytest.mark.parametrize("imputer_constructor", [SimpleImputer, IterativeImputer]) def test_imputer_without_indicator(imputer_constructor):

diff --git a/doc/whats_new/v0.22.rst b/doc/whats_new/v0.22.rst index 4ae47980a51da..8c90650c3a1f0 100644 --- a/doc/whats_new/v0.22.rst +++ b/doc/whats_new/v0.22.rst @@ -307,6 +307,10 @@ Changelog k-Nearest Neighbors. :issue:`12852` by :user:`Ashim Bhattarai <ashimb9>` and `Thomas Fan`_. +- |Enhancement| Adds parameter `add_indicator` to :class:`imputer.KNNImputer` + to get indicator of missing data. + :pr:`15010` by :user:`Guillaume Lemaitre <glemaitre>`. + - |Feature| :class:`impute.IterativeImputer` has new `skip_compute` flag that is False by default, which, when True, will skip computation on features that have no missing values during the fit phase. :issue:`13773` by

[ { "components": [ { "doc": "Base class for all imputers.\n\nIt adds automatically support for `add_indicator`.", "lines": [ 65, 115 ], "name": "_BaseImputer", "signature": "class _BaseImputer(TransformerMixin, BaseEstimator):", "type": "c...

[ "sklearn/impute/tests/test_base.py::test_base_imputer_not_fit", "sklearn/impute/tests/test_base.py::test_base_imputer_not_transform", "sklearn/impute/tests/test_common.py::test_imputation_missing_value_in_test_array[imputer0]", "sklearn/impute/tests/test_common.py::test_imputation_missing_value_in_test_array[...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG] ENH add missing indicator in KNNImputer Add the `add_indicator` to KNNImputer for consistency with other imputers. Since all imputers would share this feature, we can create a private base class. TODO: - [x] add the missing indicator to `KNNImputer` - [x] potentially create a base class for all future imputer - [x] add either common test / test for KNNImputer For another PR - [ ] update the example to use the feature + notebook style ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/impute/_base.py] (definition of _BaseImputer:) class _BaseImputer(TransformerMixin, BaseEstimator): """Base class for all imputers. It adds automatically support for `add_indicator`.""" (definition of _BaseImputer.__init__:) def __init__(self, missing_values=np.nan, add_indicator=False): (definition of _BaseImputer._fit_indicator:) def _fit_indicator(self, X): """Fit a MissingIndicator.""" (definition of _BaseImputer._transform_indicator:) def _transform_indicator(self, X): """Compute the indicator mask.' Note that X must be the original data as passed to the imputer before any imputation, since imputation may be done inplace in some cases.""" (definition of _BaseImputer._concatenate_indicator:) def _concatenate_indicator(self, X_imputed, X_indicator): """Concatenate indicator mask with the imputed data.""" (definition of _BaseImputer._more_tags:) def _more_tags(self): [end of new definitions in sklearn/impute/_base.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c96e0958da46ebef482a4084cdda3285d5f5ad23

scikit-learn__scikit-learn-15007

15,007

scikit-learn/scikit-learn

0.24

91a0e4041e6a7ec3752b394956473503e87a5924

2019-09-18T06:03:48Z

diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 35fa24ac9a846..b7b1c490777bd 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -900,7 +900,7 @@ Miscellaneous manifold.smacof manifold.spectral_embedding manifold.trustworthiness - + .. _metrics_ref: @@ -981,6 +981,7 @@ details. metrics.mean_squared_error metrics.mean_squared_log_error metrics.median_absolute_error + metrics.mean_absolute_percentage_error metrics.r2_score metrics.mean_poisson_deviance metrics.mean_gamma_deviance diff --git a/doc/modules/model_evaluation.rst b/doc/modules/model_evaluation.rst index cdbbc0814c8b1..bb8b59889a3f5 100644 --- a/doc/modules/model_evaluation.rst +++ b/doc/modules/model_evaluation.rst @@ -54,51 +54,52 @@ the model and the data, like :func:`metrics.mean_squared_error`, are available as neg_mean_squared_error which return the negated value of the metric. -============================== ============================================= ================================== -Scoring Function Comment -============================== ============================================= ================================== +==================================== ============================================== ================================== +Scoring Function Comment +==================================== ============================================== ================================== **Classification** -'accuracy' :func:`metrics.accuracy_score` -'balanced_accuracy' :func:`metrics.balanced_accuracy_score` -'average_precision' :func:`metrics.average_precision_score` -'neg_brier_score' :func:`metrics.brier_score_loss` -'f1' :func:`metrics.f1_score` for binary targets -'f1_micro' :func:`metrics.f1_score` micro-averaged -'f1_macro' :func:`metrics.f1_score` macro-averaged -'f1_weighted' :func:`metrics.f1_score` weighted average -'f1_samples' :func:`metrics.f1_score` by multilabel sample -'neg_log_loss' :func:`metrics.log_loss` requires ``predict_proba`` support -'precision' etc. :func:`metrics.precision_score` suffixes apply as with 'f1' -'recall' etc. :func:`metrics.recall_score` suffixes apply as with 'f1' -'jaccard' etc. :func:`metrics.jaccard_score` suffixes apply as with 'f1' -'roc_auc' :func:`metrics.roc_auc_score` -'roc_auc_ovr' :func:`metrics.roc_auc_score` -'roc_auc_ovo' :func:`metrics.roc_auc_score` -'roc_auc_ovr_weighted' :func:`metrics.roc_auc_score` -'roc_auc_ovo_weighted' :func:`metrics.roc_auc_score` +'accuracy' :func:`metrics.accuracy_score` +'balanced_accuracy' :func:`metrics.balanced_accuracy_score` +'average_precision' :func:`metrics.average_precision_score` +'neg_brier_score' :func:`metrics.brier_score_loss` +'f1' :func:`metrics.f1_score` for binary targets +'f1_micro' :func:`metrics.f1_score` micro-averaged +'f1_macro' :func:`metrics.f1_score` macro-averaged +'f1_weighted' :func:`metrics.f1_score` weighted average +'f1_samples' :func:`metrics.f1_score` by multilabel sample +'neg_log_loss' :func:`metrics.log_loss` requires ``predict_proba`` support +'precision' etc. :func:`metrics.precision_score` suffixes apply as with 'f1' +'recall' etc. :func:`metrics.recall_score` suffixes apply as with 'f1' +'jaccard' etc. :func:`metrics.jaccard_score` suffixes apply as with 'f1' +'roc_auc' :func:`metrics.roc_auc_score` +'roc_auc_ovr' :func:`metrics.roc_auc_score` +'roc_auc_ovo' :func:`metrics.roc_auc_score` +'roc_auc_ovr_weighted' :func:`metrics.roc_auc_score` +'roc_auc_ovo_weighted' :func:`metrics.roc_auc_score` **Clustering** -'adjusted_mutual_info_score' :func:`metrics.adjusted_mutual_info_score` -'adjusted_rand_score' :func:`metrics.adjusted_rand_score` -'completeness_score' :func:`metrics.completeness_score` -'fowlkes_mallows_score' :func:`metrics.fowlkes_mallows_score` -'homogeneity_score' :func:`metrics.homogeneity_score` -'mutual_info_score' :func:`metrics.mutual_info_score` -'normalized_mutual_info_score' :func:`metrics.normalized_mutual_info_score` -'v_measure_score' :func:`metrics.v_measure_score` +'adjusted_mutual_info_score' :func:`metrics.adjusted_mutual_info_score` +'adjusted_rand_score' :func:`metrics.adjusted_rand_score` +'completeness_score' :func:`metrics.completeness_score` +'fowlkes_mallows_score' :func:`metrics.fowlkes_mallows_score` +'homogeneity_score' :func:`metrics.homogeneity_score` +'mutual_info_score' :func:`metrics.mutual_info_score` +'normalized_mutual_info_score' :func:`metrics.normalized_mutual_info_score` +'v_measure_score' :func:`metrics.v_measure_score` **Regression** -'explained_variance' :func:`metrics.explained_variance_score` -'max_error' :func:`metrics.max_error` -'neg_mean_absolute_error' :func:`metrics.mean_absolute_error` -'neg_mean_squared_error' :func:`metrics.mean_squared_error` -'neg_root_mean_squared_error' :func:`metrics.mean_squared_error` -'neg_mean_squared_log_error' :func:`metrics.mean_squared_log_error` -'neg_median_absolute_error' :func:`metrics.median_absolute_error` -'r2' :func:`metrics.r2_score` -'neg_mean_poisson_deviance' :func:`metrics.mean_poisson_deviance` -'neg_mean_gamma_deviance' :func:`metrics.mean_gamma_deviance` -============================== ============================================= ================================== +'explained_variance' :func:`metrics.explained_variance_score` +'max_error' :func:`metrics.max_error` +'neg_mean_absolute_error' :func:`metrics.mean_absolute_error` +'neg_mean_squared_error' :func:`metrics.mean_squared_error` +'neg_root_mean_squared_error' :func:`metrics.mean_squared_error` +'neg_mean_squared_log_error' :func:`metrics.mean_squared_log_error` +'neg_median_absolute_error' :func:`metrics.median_absolute_error` +'r2' :func:`metrics.r2_score` +'neg_mean_poisson_deviance' :func:`metrics.mean_poisson_deviance` +'neg_mean_gamma_deviance' :func:`metrics.mean_gamma_deviance` +'neg_mean_absolute_percentage_error' :func:`metrics.mean_absolute_percentage_error` +==================================== ============================================== ================================== Usage examples: @@ -1963,6 +1964,42 @@ function:: >>> mean_squared_log_error(y_true, y_pred) 0.044... +.. _mean_absolute_percentage_error: + +Mean absolute percentage error +------------------------------ +The :func:`mean_absolute_percentage_error` (MAPE), also known as mean absolute +percentage deviation (MAPD), is an evaluation metric for regression problems. +The idea of this metric is to be sensitive to relative errors. It is for example +not changed by a global scaling of the target variable. + +If :math:`\hat{y}_i` is the predicted value of the :math:`i`-th sample +and :math:`y_i` is the corresponding true value, then the mean absolute percentage +error (MAPE) estimated over :math:`n_{\text{samples}}` is defined as + +.. math:: + + \text{MAPE}(y, \hat{y}) = \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}}-1} \frac{{}\left| y_i - \hat{y}_i \right|}{max(\epsilon, \left| y_i \right|)} + +where :math:`\epsilon` is an arbitrary small yet strictly positive number to +avoid undefined results when y is zero. + +The :func:`mean_absolute_percentage_error` function supports multioutput. + +Here is a small example of usage of the :func:`mean_absolute_percentage_error` +function:: + + >>> from sklearn.metrics import mean_absolute_percentage_error + >>> y_true = [1, 10, 1e6] + >>> y_pred = [0.9, 15, 1.2e6] + >>> mean_absolute_percentage_error(y_true, y_pred) + 0.2666... + +In above example, if we had used `mean_absolute_error`, it would have ignored +the small magnitude values and only reflected the error in prediction of highest +magnitude value. But that problem is resolved in case of MAPE because it calculates +relative percentage error with respect to actual output. + .. _median_absolute_error: Median absolute error diff --git a/doc/whats_new/_contributors.rst b/doc/whats_new/_contributors.rst index cc3957eca1592..ca0f8ede93afa 100644 --- a/doc/whats_new/_contributors.rst +++ b/doc/whats_new/_contributors.rst @@ -176,4 +176,4 @@ .. _Nicolas Hug: https://github.com/NicolasHug -.. _Guillaume Lemaitre: https://github.com/glemaitre +.. _Guillaume Lemaitre: https://github.com/glemaitre \ No newline at end of file diff --git a/doc/whats_new/v0.24.rst b/doc/whats_new/v0.24.rst index c41f761de1018..e637e367d401e 100644 --- a/doc/whats_new/v0.24.rst +++ b/doc/whats_new/v0.24.rst @@ -150,6 +150,12 @@ Changelog :mod:`sklearn.metrics` ...................... +- |Feature| Added :func:`metrics.mean_absolute_percentage_error` metric and + the associated scorer for regression problems. :issue:`10708` fixed with the + PR :pr:`15007` by :user:`Ashutosh Hathidara <ashutosh1919>`. The scorer and + some practical test cases were taken from PR :pr:`10711` by + :user:`Mohamed Ali Jamaoui <mohamed-ali>`. + - |Fix| Fixed a bug in :func:`metrics.mean_squared_error` where the average of multiple RMSE values was incorrectly calculated as the root of the average of multiple MSE values. diff --git a/sklearn/metrics/__init__.py b/sklearn/metrics/__init__.py index 8bcb047ec8161..be28005631963 100644 --- a/sklearn/metrics/__init__.py +++ b/sklearn/metrics/__init__.py @@ -64,6 +64,7 @@ from ._regression import mean_squared_error from ._regression import mean_squared_log_error from ._regression import median_absolute_error +from ._regression import mean_absolute_percentage_error from ._regression import r2_score from ._regression import mean_tweedie_deviance from ._regression import mean_poisson_deviance @@ -128,6 +129,7 @@ 'mean_gamma_deviance', 'mean_tweedie_deviance', 'median_absolute_error', + 'mean_absolute_percentage_error', 'multilabel_confusion_matrix', 'mutual_info_score', 'ndcg_score', diff --git a/sklearn/metrics/_regression.py b/sklearn/metrics/_regression.py index 9064c018a24a9..ff3907d3c27ae 100644 --- a/sklearn/metrics/_regression.py +++ b/sklearn/metrics/_regression.py @@ -20,6 +20,7 @@ # Michael Eickenberg <michael.eickenberg@gmail.com> # Konstantin Shmelkov <konstantin.shmelkov@polytechnique.edu> # Christian Lorentzen <lorentzen.ch@googlemail.com> +# Ashutosh Hathidara <ashutoshhathidara98@gmail.com> # License: BSD 3 clause import numpy as np @@ -41,6 +42,7 @@ "mean_squared_error", "mean_squared_log_error", "median_absolute_error", + "mean_absolute_percentage_error", "r2_score", "explained_variance_score", "mean_tweedie_deviance", @@ -192,6 +194,81 @@ def mean_absolute_error(y_true, y_pred, *, return np.average(output_errors, weights=multioutput) +def mean_absolute_percentage_error(y_true, y_pred, + sample_weight=None, + multioutput='uniform_average'): + """Mean absolute percentage error regression loss + + Note here that we do not represent the output as a percentage in range + [0, 100]. Instead, we represent it in range [0, 1/eps]. Read more in the + :ref:`User Guide <mean_absolute_percentage_error>`. + + Parameters + ---------- + y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) + Ground truth (correct) target values. + + y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) + Estimated target values. + + sample_weight : array-like of shape (n_samples,), default=None + Sample weights. + + multioutput : {'raw_values', 'uniform_average'} or array-like + Defines aggregating of multiple output values. + Array-like value defines weights used to average errors. + If input is list then the shape must be (n_outputs,). + + 'raw_values' : + Returns a full set of errors in case of multioutput input. + + 'uniform_average' : + Errors of all outputs are averaged with uniform weight. + + Returns + ------- + loss : float or ndarray of floats in the range [0, 1/eps] + If multioutput is 'raw_values', then mean absolute percentage error + is returned for each output separately. + If multioutput is 'uniform_average' or an ndarray of weights, then the + weighted average of all output errors is returned. + + MAPE output is non-negative floating point. The best value is 0.0. + But note the fact that bad predictions can lead to arbitarily large + MAPE values, especially if some y_true values are very close to zero. + Note that we return a large value instead of `inf` when y_true is zero. + + Examples + -------- + >>> from sklearn.metrics import mean_absolute_percentage_error + >>> y_true = [3, -0.5, 2, 7] + >>> y_pred = [2.5, 0.0, 2, 8] + >>> mean_absolute_percentage_error(y_true, y_pred) + 0.3273... + >>> y_true = [[0.5, 1], [-1, 1], [7, -6]] + >>> y_pred = [[0, 2], [-1, 2], [8, -5]] + >>> mean_absolute_percentage_error(y_true, y_pred) + 0.5515... + >>> mean_absolute_percentage_error(y_true, y_pred, multioutput=[0.3, 0.7]) + 0.6198... + """ + y_type, y_true, y_pred, multioutput = _check_reg_targets( + y_true, y_pred, multioutput) + check_consistent_length(y_true, y_pred, sample_weight) + epsilon = np.finfo(np.float64).eps + mape = np.abs(y_pred - y_true) / np.maximum(np.abs(y_true), epsilon) + output_errors = np.average(mape, + weights=sample_weight, axis=0) + if isinstance(multioutput, str): + if multioutput == 'raw_values': + return output_errors + elif multioutput == 'uniform_average': + # pass None as weights to np.average: uniform mean + multioutput = None + + return np.average(output_errors, weights=multioutput) + + @_deprecate_positional_args def mean_squared_error(y_true, y_pred, *, sample_weight=None, diff --git a/sklearn/metrics/_scorer.py b/sklearn/metrics/_scorer.py index 1f05462928916..6098eae2d68a0 100644 --- a/sklearn/metrics/_scorer.py +++ b/sklearn/metrics/_scorer.py @@ -30,7 +30,7 @@ f1_score, roc_auc_score, average_precision_score, precision_score, recall_score, log_loss, balanced_accuracy_score, explained_variance_score, - brier_score_loss, jaccard_score) + brier_score_loss, jaccard_score, mean_absolute_percentage_error) from .cluster import adjusted_rand_score from .cluster import homogeneity_score @@ -614,6 +614,9 @@ def make_scorer(score_func, *, greater_is_better=True, needs_proba=False, greater_is_better=False) neg_mean_absolute_error_scorer = make_scorer(mean_absolute_error, greater_is_better=False) +neg_mean_absolute_percentage_error_scorer = make_scorer( + mean_absolute_percentage_error, greater_is_better=False +) neg_median_absolute_error_scorer = make_scorer(median_absolute_error, greater_is_better=False) neg_root_mean_squared_error_scorer = make_scorer(mean_squared_error, @@ -674,6 +677,7 @@ def make_scorer(score_func, *, greater_is_better=True, needs_proba=False, max_error=max_error_scorer, neg_median_absolute_error=neg_median_absolute_error_scorer, neg_mean_absolute_error=neg_mean_absolute_error_scorer, + neg_mean_absolute_percentage_error=neg_mean_absolute_percentage_error_scorer, # noqa neg_mean_squared_error=neg_mean_squared_error_scorer, neg_mean_squared_log_error=neg_mean_squared_log_error_scorer, neg_root_mean_squared_error=neg_root_mean_squared_error_scorer,

diff --git a/sklearn/metrics/tests/test_common.py b/sklearn/metrics/tests/test_common.py index 7301d21a35f39..3f2ba83b474c7 100644 --- a/sklearn/metrics/tests/test_common.py +++ b/sklearn/metrics/tests/test_common.py @@ -41,6 +41,7 @@ from sklearn.metrics import max_error from sklearn.metrics import matthews_corrcoef from sklearn.metrics import mean_absolute_error +from sklearn.metrics import mean_absolute_percentage_error from sklearn.metrics import mean_squared_error from sklearn.metrics import mean_tweedie_deviance from sklearn.metrics import mean_poisson_deviance @@ -98,6 +99,7 @@ "mean_absolute_error": mean_absolute_error, "mean_squared_error": mean_squared_error, "median_absolute_error": median_absolute_error, + "mean_absolute_percentage_error": mean_absolute_percentage_error, "explained_variance_score": explained_variance_score, "r2_score": partial(r2_score, multioutput='variance_weighted'), "mean_normal_deviance": partial(mean_tweedie_deviance, power=0), @@ -425,7 +427,7 @@ def precision_recall_curve_padded_thresholds(*args, **kwargs): # Regression metrics with "multioutput-continuous" format support MULTIOUTPUT_METRICS = { "mean_absolute_error", "median_absolute_error", "mean_squared_error", - "r2_score", "explained_variance_score" + "r2_score", "explained_variance_score", "mean_absolute_percentage_error" } # Symmetric with respect to their input arguments y_true and y_pred @@ -472,7 +474,7 @@ def precision_recall_curve_padded_thresholds(*args, **kwargs): "macro_f0.5_score", "macro_f2_score", "macro_precision_score", "macro_recall_score", "log_loss", "hinge_loss", "mean_gamma_deviance", "mean_poisson_deviance", - "mean_compound_poisson_deviance" + "mean_compound_poisson_deviance", "mean_absolute_percentage_error" } @@ -1371,7 +1373,15 @@ def test_thresholded_multilabel_multioutput_permutations_invariance(name): y_true_perm = y_true[:, perm] current_score = metric(y_true_perm, y_score_perm) - assert_almost_equal(score, current_score) + if metric == mean_absolute_percentage_error: + assert np.isfinite(current_score) + assert current_score > 1e6 + # Here we are not comparing the values in case of MAPE because + # whenever y_true value is exactly zero, the MAPE value doesn't + # signify anything. Thus, in this case we are just expecting + # very large finite value. + else: + assert_almost_equal(score, current_score) @pytest.mark.parametrize( diff --git a/sklearn/metrics/tests/test_regression.py b/sklearn/metrics/tests/test_regression.py index c5e9743539612..5b8406cf7a61f 100644 --- a/sklearn/metrics/tests/test_regression.py +++ b/sklearn/metrics/tests/test_regression.py @@ -13,6 +13,7 @@ from sklearn.metrics import mean_squared_error from sklearn.metrics import mean_squared_log_error from sklearn.metrics import median_absolute_error +from sklearn.metrics import mean_absolute_percentage_error from sklearn.metrics import max_error from sklearn.metrics import r2_score from sklearn.metrics import mean_tweedie_deviance @@ -32,6 +33,9 @@ def test_regression_metrics(n_samples=50): np.log(1 + y_pred))) assert_almost_equal(mean_absolute_error(y_true, y_pred), 1.) assert_almost_equal(median_absolute_error(y_true, y_pred), 1.) + mape = mean_absolute_percentage_error(y_true, y_pred) + assert np.isfinite(mape) + assert mape > 1e6 assert_almost_equal(max_error(y_true, y_pred), 1.) assert_almost_equal(r2_score(y_true, y_pred), 0.995, 2) assert_almost_equal(explained_variance_score(y_true, y_pred), 1.) @@ -86,6 +90,10 @@ def test_multioutput_regression(): error = mean_absolute_error(y_true, y_pred) assert_almost_equal(error, (1. + 2. / 3) / 4.) + error = np.around(mean_absolute_percentage_error(y_true, y_pred), + decimals=2) + assert np.isfinite(error) + assert error > 1e6 error = median_absolute_error(y_true, y_pred) assert_almost_equal(error, (1. + 1.) / 4.) @@ -100,6 +108,7 @@ def test_regression_metrics_at_limits(): assert_almost_equal(mean_squared_error([0.], [0.], squared=False), 0.00, 2) assert_almost_equal(mean_squared_log_error([0.], [0.]), 0.00, 2) assert_almost_equal(mean_absolute_error([0.], [0.]), 0.00, 2) + assert_almost_equal(mean_absolute_percentage_error([0.], [0.]), 0.00, 2) assert_almost_equal(median_absolute_error([0.], [0.]), 0.00, 2) assert_almost_equal(max_error([0.], [0.]), 0.00, 2) assert_almost_equal(explained_variance_score([0.], [0.]), 1.00, 2) @@ -198,11 +207,14 @@ def test_regression_multioutput_array(): mse = mean_squared_error(y_true, y_pred, multioutput='raw_values') mae = mean_absolute_error(y_true, y_pred, multioutput='raw_values') + mape = mean_absolute_percentage_error(y_true, y_pred, + multioutput='raw_values') r = r2_score(y_true, y_pred, multioutput='raw_values') evs = explained_variance_score(y_true, y_pred, multioutput='raw_values') assert_array_almost_equal(mse, [0.125, 0.5625], decimal=2) assert_array_almost_equal(mae, [0.25, 0.625], decimal=2) + assert_array_almost_equal(mape, [0.0778, 0.2262], decimal=2) assert_array_almost_equal(r, [0.95, 0.93], decimal=2) assert_array_almost_equal(evs, [0.95, 0.93], decimal=2) @@ -254,12 +266,15 @@ def test_regression_custom_weights(): rmsew = mean_squared_error(y_true, y_pred, multioutput=[0.4, 0.6], squared=False) maew = mean_absolute_error(y_true, y_pred, multioutput=[0.4, 0.6]) + mapew = mean_absolute_percentage_error(y_true, y_pred, + multioutput=[0.4, 0.6]) rw = r2_score(y_true, y_pred, multioutput=[0.4, 0.6]) evsw = explained_variance_score(y_true, y_pred, multioutput=[0.4, 0.6]) assert_almost_equal(msew, 0.39, decimal=2) assert_almost_equal(rmsew, 0.59, decimal=2) assert_almost_equal(maew, 0.475, decimal=3) + assert_almost_equal(mapew, 0.1668, decimal=2) assert_almost_equal(rw, 0.94, decimal=2) assert_almost_equal(evsw, 0.94, decimal=2) @@ -308,3 +323,10 @@ def test_tweedie_deviance_continuity(): assert_allclose(mean_tweedie_deviance(y_true, y_pred, power=2 + 1e-10), mean_tweedie_deviance(y_true, y_pred, power=2), atol=1e-6) + + +def test_mean_absolute_percentage_error(): + random_number_generator = np.random.RandomState(42) + y_true = random_number_generator.exponential(size=100) + y_pred = 1.2 * y_true + assert mean_absolute_percentage_error(y_true, y_pred) == pytest.approx(0.2) diff --git a/sklearn/metrics/tests/test_score_objects.py b/sklearn/metrics/tests/test_score_objects.py index f49197a706e70..227fd8bbadee9 100644 --- a/sklearn/metrics/tests/test_score_objects.py +++ b/sklearn/metrics/tests/test_score_objects.py @@ -43,10 +43,12 @@ REGRESSION_SCORERS = ['explained_variance', 'r2', 'neg_mean_absolute_error', 'neg_mean_squared_error', + 'neg_mean_absolute_percentage_error', 'neg_mean_squared_log_error', 'neg_median_absolute_error', 'neg_root_mean_squared_error', 'mean_absolute_error', + 'mean_absolute_percentage_error', 'mean_squared_error', 'median_absolute_error', 'max_error', 'neg_mean_poisson_deviance', 'neg_mean_gamma_deviance']

diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 35fa24ac9a846..b7b1c490777bd 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -900,7 +900,7 @@ Miscellaneous manifold.smacof manifold.spectral_embedding manifold.trustworthiness - + .. _metrics_ref: @@ -981,6 +981,7 @@ details. metrics.mean_squared_error metrics.mean_squared_log_error metrics.median_absolute_error + metrics.mean_absolute_percentage_error metrics.r2_score metrics.mean_poisson_deviance metrics.mean_gamma_deviance diff --git a/doc/modules/model_evaluation.rst b/doc/modules/model_evaluation.rst index cdbbc0814c8b1..bb8b59889a3f5 100644 --- a/doc/modules/model_evaluation.rst +++ b/doc/modules/model_evaluation.rst @@ -54,51 +54,52 @@ the model and the data, like :func:`metrics.mean_squared_error`, are available as neg_mean_squared_error which return the negated value of the metric. -============================== ============================================= ================================== -Scoring Function Comment -============================== ============================================= ================================== +==================================== ============================================== ================================== +Scoring Function Comment +==================================== ============================================== ================================== **Classification** -'accuracy' :func:`metrics.accuracy_score` -'balanced_accuracy' :func:`metrics.balanced_accuracy_score` -'average_precision' :func:`metrics.average_precision_score` -'neg_brier_score' :func:`metrics.brier_score_loss` -'f1' :func:`metrics.f1_score` for binary targets -'f1_micro' :func:`metrics.f1_score` micro-averaged -'f1_macro' :func:`metrics.f1_score` macro-averaged -'f1_weighted' :func:`metrics.f1_score` weighted average -'f1_samples' :func:`metrics.f1_score` by multilabel sample -'neg_log_loss' :func:`metrics.log_loss` requires ``predict_proba`` support -'precision' etc. :func:`metrics.precision_score` suffixes apply as with 'f1' -'recall' etc. :func:`metrics.recall_score` suffixes apply as with 'f1' -'jaccard' etc. :func:`metrics.jaccard_score` suffixes apply as with 'f1' -'roc_auc' :func:`metrics.roc_auc_score` -'roc_auc_ovr' :func:`metrics.roc_auc_score` -'roc_auc_ovo' :func:`metrics.roc_auc_score` -'roc_auc_ovr_weighted' :func:`metrics.roc_auc_score` -'roc_auc_ovo_weighted' :func:`metrics.roc_auc_score` +'accuracy' :func:`metrics.accuracy_score` +'balanced_accuracy' :func:`metrics.balanced_accuracy_score` +'average_precision' :func:`metrics.average_precision_score` +'neg_brier_score' :func:`metrics.brier_score_loss` +'f1' :func:`metrics.f1_score` for binary targets +'f1_micro' :func:`metrics.f1_score` micro-averaged +'f1_macro' :func:`metrics.f1_score` macro-averaged +'f1_weighted' :func:`metrics.f1_score` weighted average +'f1_samples' :func:`metrics.f1_score` by multilabel sample +'neg_log_loss' :func:`metrics.log_loss` requires ``predict_proba`` support +'precision' etc. :func:`metrics.precision_score` suffixes apply as with 'f1' +'recall' etc. :func:`metrics.recall_score` suffixes apply as with 'f1' +'jaccard' etc. :func:`metrics.jaccard_score` suffixes apply as with 'f1' +'roc_auc' :func:`metrics.roc_auc_score` +'roc_auc_ovr' :func:`metrics.roc_auc_score` +'roc_auc_ovo' :func:`metrics.roc_auc_score` +'roc_auc_ovr_weighted' :func:`metrics.roc_auc_score` +'roc_auc_ovo_weighted' :func:`metrics.roc_auc_score` **Clustering** -'adjusted_mutual_info_score' :func:`metrics.adjusted_mutual_info_score` -'adjusted_rand_score' :func:`metrics.adjusted_rand_score` -'completeness_score' :func:`metrics.completeness_score` -'fowlkes_mallows_score' :func:`metrics.fowlkes_mallows_score` -'homogeneity_score' :func:`metrics.homogeneity_score` -'mutual_info_score' :func:`metrics.mutual_info_score` -'normalized_mutual_info_score' :func:`metrics.normalized_mutual_info_score` -'v_measure_score' :func:`metrics.v_measure_score` +'adjusted_mutual_info_score' :func:`metrics.adjusted_mutual_info_score` +'adjusted_rand_score' :func:`metrics.adjusted_rand_score` +'completeness_score' :func:`metrics.completeness_score` +'fowlkes_mallows_score' :func:`metrics.fowlkes_mallows_score` +'homogeneity_score' :func:`metrics.homogeneity_score` +'mutual_info_score' :func:`metrics.mutual_info_score` +'normalized_mutual_info_score' :func:`metrics.normalized_mutual_info_score` +'v_measure_score' :func:`metrics.v_measure_score` **Regression** -'explained_variance' :func:`metrics.explained_variance_score` -'max_error' :func:`metrics.max_error` -'neg_mean_absolute_error' :func:`metrics.mean_absolute_error` -'neg_mean_squared_error' :func:`metrics.mean_squared_error` -'neg_root_mean_squared_error' :func:`metrics.mean_squared_error` -'neg_mean_squared_log_error' :func:`metrics.mean_squared_log_error` -'neg_median_absolute_error' :func:`metrics.median_absolute_error` -'r2' :func:`metrics.r2_score` -'neg_mean_poisson_deviance' :func:`metrics.mean_poisson_deviance` -'neg_mean_gamma_deviance' :func:`metrics.mean_gamma_deviance` -============================== ============================================= ================================== +'explained_variance' :func:`metrics.explained_variance_score` +'max_error' :func:`metrics.max_error` +'neg_mean_absolute_error' :func:`metrics.mean_absolute_error` +'neg_mean_squared_error' :func:`metrics.mean_squared_error` +'neg_root_mean_squared_error' :func:`metrics.mean_squared_error` +'neg_mean_squared_log_error' :func:`metrics.mean_squared_log_error` +'neg_median_absolute_error' :func:`metrics.median_absolute_error` +'r2' :func:`metrics.r2_score` +'neg_mean_poisson_deviance' :func:`metrics.mean_poisson_deviance` +'neg_mean_gamma_deviance' :func:`metrics.mean_gamma_deviance` +'neg_mean_absolute_percentage_error' :func:`metrics.mean_absolute_percentage_error` +==================================== ============================================== ================================== Usage examples: @@ -1963,6 +1964,42 @@ function:: >>> mean_squared_log_error(y_true, y_pred) 0.044... +.. _mean_absolute_percentage_error: + +Mean absolute percentage error +------------------------------ +The :func:`mean_absolute_percentage_error` (MAPE), also known as mean absolute +percentage deviation (MAPD), is an evaluation metric for regression problems. +The idea of this metric is to be sensitive to relative errors. It is for example +not changed by a global scaling of the target variable. + +If :math:`\hat{y}_i` is the predicted value of the :math:`i`-th sample +and :math:`y_i` is the corresponding true value, then the mean absolute percentage +error (MAPE) estimated over :math:`n_{\text{samples}}` is defined as + +.. math:: + + \text{MAPE}(y, \hat{y}) = \frac{1}{n_{\text{samples}}} \sum_{i=0}^{n_{\text{samples}}-1} \frac{{}\left| y_i - \hat{y}_i \right|}{max(\epsilon, \left| y_i \right|)} + +where :math:`\epsilon` is an arbitrary small yet strictly positive number to +avoid undefined results when y is zero. + +The :func:`mean_absolute_percentage_error` function supports multioutput. + +Here is a small example of usage of the :func:`mean_absolute_percentage_error` +function:: + + >>> from sklearn.metrics import mean_absolute_percentage_error + >>> y_true = [1, 10, 1e6] + >>> y_pred = [0.9, 15, 1.2e6] + >>> mean_absolute_percentage_error(y_true, y_pred) + 0.2666... + +In above example, if we had used `mean_absolute_error`, it would have ignored +the small magnitude values and only reflected the error in prediction of highest +magnitude value. But that problem is resolved in case of MAPE because it calculates +relative percentage error with respect to actual output. + .. _median_absolute_error: Median absolute error diff --git a/doc/whats_new/_contributors.rst b/doc/whats_new/_contributors.rst index cc3957eca1592..ca0f8ede93afa 100644 --- a/doc/whats_new/_contributors.rst +++ b/doc/whats_new/_contributors.rst @@ -176,4 +176,4 @@ .. _Nicolas Hug: https://github.com/NicolasHug -.. _Guillaume Lemaitre: https://github.com/glemaitre +.. _Guillaume Lemaitre: https://github.com/glemaitre \ No newline at end of file diff --git a/doc/whats_new/v0.24.rst b/doc/whats_new/v0.24.rst index c41f761de1018..e637e367d401e 100644 --- a/doc/whats_new/v0.24.rst +++ b/doc/whats_new/v0.24.rst @@ -150,6 +150,12 @@ Changelog :mod:`sklearn.metrics` ...................... +- |Feature| Added :func:`metrics.mean_absolute_percentage_error` metric and + the associated scorer for regression problems. :issue:`10708` fixed with the + PR :pr:`15007` by :user:`Ashutosh Hathidara <ashutosh1919>`. The scorer and + some practical test cases were taken from PR :pr:`10711` by + :user:`Mohamed Ali Jamaoui <mohamed-ali>`. + - |Fix| Fixed a bug in :func:`metrics.mean_squared_error` where the average of multiple RMSE values was incorrectly calculated as the root of the average of multiple MSE values.

[ { "components": [ { "doc": "Mean absolute percentage error regression loss\n\nNote here that we do not represent the output as a percentage in range\n[0, 100]. Instead, we represent it in range [0, 1/eps]. Read more in the\n:ref:`User Guide <mean_absolute_percentage_error>`.\n\nParameters\n-------...

[ "sklearn/metrics/tests/test_common.py::test_symmetry_consistency", "sklearn/metrics/tests/test_common.py::test_symmetric_metric[accuracy_score]", "sklearn/metrics/tests/test_common.py::test_symmetric_metric[cohen_kappa_score]", "sklearn/metrics/tests/test_common.py::test_symmetric_metric[f1_score]", "sklear...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added mean_absolute_percentage_error in metrics fixes #10708 I have faced problem when working with any quantitative modelling algorithm. Scikit-learn doesn't have any function such **mean_absolute_percentage_error**. Everytime, when I want to use this function, then I have to implement it myself. But, if it is included in sklearn itself then it will be great. I have written code for this function and I have also added tests for it. @agramfort , Please Review my PR. ![mape](https://user-images.githubusercontent.com/20843596/65117948-26611180-da08-11e9-837d-68af24949e57.png) This PR Fixes #10708 . This PR is continuation of the work done by @mohamed-ali in #10711 PR. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/metrics/_regression.py] (definition of mean_absolute_percentage_error:) def mean_absolute_percentage_error(y_true, y_pred, sample_weight=None, multioutput='uniform_average'): """Mean absolute percentage error regression loss Note here that we do not represent the output as a percentage in range [0, 100]. Instead, we represent it in range [0, 1/eps]. Read more in the :ref:`User Guide <mean_absolute_percentage_error>`. Parameters ---------- y_true : array-like of shape (n_samples,) or (n_samples, n_outputs) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) or (n_samples, n_outputs) Estimated target values. sample_weight : array-like of shape (n_samples,), default=None Sample weights. multioutput : {'raw_values', 'uniform_average'} or array-like Defines aggregating of multiple output values. Array-like value defines weights used to average errors. If input is list then the shape must be (n_outputs,). 'raw_values' : Returns a full set of errors in case of multioutput input. 'uniform_average' : Errors of all outputs are averaged with uniform weight. Returns ------- loss : float or ndarray of floats in the range [0, 1/eps] If multioutput is 'raw_values', then mean absolute percentage error is returned for each output separately. If multioutput is 'uniform_average' or an ndarray of weights, then the weighted average of all output errors is returned. MAPE output is non-negative floating point. The best value is 0.0. But note the fact that bad predictions can lead to arbitarily large MAPE values, especially if some y_true values are very close to zero. Note that we return a large value instead of `inf` when y_true is zero. Examples -------- >>> from sklearn.metrics import mean_absolute_percentage_error >>> y_true = [3, -0.5, 2, 7] >>> y_pred = [2.5, 0.0, 2, 8] >>> mean_absolute_percentage_error(y_true, y_pred) 0.3273... >>> y_true = [[0.5, 1], [-1, 1], [7, -6]] >>> y_pred = [[0, 2], [-1, 2], [8, -5]] >>> mean_absolute_percentage_error(y_true, y_pred) 0.5515... >>> mean_absolute_percentage_error(y_true, y_pred, multioutput=[0.3, 0.7]) 0.6198...""" [end of new definitions in sklearn/metrics/_regression.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Add MAPE as evaluation metric Also see #6605. https://en.wikipedia.org/wiki/Mean_absolute_percentage_error probably need a neg_mape scorer, too. ---------- @amueller, I'd like to work on this. sure, go for it. @amueller, all sklearn metrics have an output in the`[0,1]` interval. Is it okay that this metric will have its output in `[0,100]`? or should we not multiply with 100 and only keep the fraction? @mohamed-ali not all. MSE doesn't, for example (though I guess all with a fixed range do). I think we should multiply by 100 given that it's part of the definition, even though it's slightly different from other metrics. @amueller okay great. Thanks for the quick reply :) @amueller regarding the scorer, based on the deprecation message in the following example, I assume there should be a `neg_mean_absolute_percentage_error_scorer` instead of `mean_absolute_percentage_error_scorer`: ``` neg_mean_squared_error_scorer = make_scorer(mean_squared_error, greater_is_better=False) deprecation_msg = ('Scoring method mean_squared_error was renamed to ' 'neg_mean_squared_error in version 0.18 and will ' 'be removed in 0.20.') mean_squared_error_scorer = make_scorer(mean_squared_error, greater_is_better=False) ``` https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/metrics/scorer.py#L472-L497 Is my assumption correct? if we call it mean_absolute_proportion_error we don't need the 100x yes, for the scorer, it should be neg_, but for the metric it should not. Andy proposed the scorer name neg_mape above @amueller & @jnothman, I pushed the work in progress at this pull request https://github.com/scikit-learn/scikit-learn/pull/10711. We can move the discussion there and probably vote with the core devs on right name to consider. @amueller & @jnothman, the work is done in https://github.com/scikit-learn/scikit-learn/pull/10711. Could you please do a full review? Thanks. @amueller @jnothman, out of curiosity, why do we prefix the scorer name with `neg_`? because the score is negated to follow the convention that greater is better. but users complained when we negated it without signifying so in the name @jnothman thank you! -------------------- </issues>

54ce4222694819ad52d544ce5cba5da274c34ab7

sympy__sympy-17617

17,617

sympy/sympy

1.5

def1c20c221f0bdf7feaaac7b4cd54a42bf57db7

2019-09-16T17:49:23Z

diff --git a/doc/src/modules/crypto.rst b/doc/src/modules/crypto.rst index 14aabee76638..43a916b64797 100644 --- a/doc/src/modules/crypto.rst +++ b/doc/src/modules/crypto.rst @@ -142,3 +142,7 @@ substitutions at different times in the message. .. autofunction:: encipher_gm .. autofunction:: decipher_gm + +.. autofunction:: encipher_railfence + +.. autofunction:: decipher_railfence diff --git a/sympy/crypto/__init__.py b/sympy/crypto/__init__.py index 0ba69df2379f..3896e8943c9d 100644 --- a/sympy/crypto/__init__.py +++ b/sympy/crypto/__init__.py @@ -12,4 +12,5 @@ padded_key, encipher_bifid, decipher_bifid, bifid_square, bifid5, bifid6, bifid10, decipher_gm, encipher_gm, gm_public_key, gm_private_key, bg_private_key, bg_public_key, encipher_bg, decipher_bg, - encipher_rot13, decipher_rot13, encipher_atbash, decipher_atbash) + encipher_rot13, decipher_rot13, encipher_atbash, decipher_atbash, + encipher_railfence, decipher_railfence) diff --git a/sympy/crypto/crypto.py b/sympy/crypto/crypto.py index af060dbfcfcf..4f97162d48ee 100644 --- a/sympy/crypto/crypto.py +++ b/sympy/crypto/crypto.py @@ -20,6 +20,8 @@ from functools import reduce import warnings +from itertools import cycle + from sympy import nextprime from sympy.core import Rational, Symbol from sympy.core.numbers import igcdex, mod_inverse, igcd @@ -2699,7 +2701,7 @@ def decipher_elgamal(msg, key): True """ - p, r, d = key + p, _, d = key c1, c2 = msg u = igcdex(c1**d, p)[0] return u * c2 % p @@ -3069,6 +3071,76 @@ def decipher_gm(message, key): m += not b return m + + +########### RailFence Cipher ############# + +def encipher_railfence(message,rails): + """ + Performs Railfence Encryption on plaintext and returns ciphertext + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_railfence + >>> message = "hello world" + >>> encipher_railfence(message,3) + 'horel ollwd' + + Parameters + ========== + + message : string, the message to encrypt. + rails : int, the number of rails. + + Returns + ======= + + The Encrypted string message. + + References + ========== + .. [1] https://en.wikipedia.org/wiki/Rail_fence_cipher + + """ + r = list(range(rails)) + p = cycle(r + r[-2:0:-1]) + return ''.join(sorted(message, key=lambda i: next(p))) + + +def decipher_railfence(ciphertext,rails): + """ + Decrypt the message using the given rails + + Examples + ======== + + >>> from sympy.crypto.crypto import decipher_railfence + >>> decipher_railfence("horel ollwd",3) + 'hello world' + + Parameters + ========== + + message : string, the message to encrypt. + rails : int, the number of rails. + + Returns + ======= + + The Decrypted string message. + + """ + r = list(range(rails)) + p = cycle(r + r[-2:0:-1]) + + idx = sorted(range(len(ciphertext)), key=lambda i: next(p)) + res = [''] * len(ciphertext) + for i, c in zip(idx, ciphertext): + res[i] = c + return ''.join(res) + + ################ Blum–Goldwasser cryptosystem ######################### def bg_private_key(p, q): @@ -3193,7 +3265,7 @@ def encipher_bg(i, key, seed=None): x_L = pow(int(x), int(2**L), int(key)) rand_bits = [] - for k in range(L): + for _ in range(L): rand_bits.append(x % 2) x = x**2 % key @@ -3244,7 +3316,7 @@ def decipher_bg(message, key): x = (q * mod_inverse(q, p) * r_p + p * mod_inverse(p, q) * r_q) % public_key orig_bits = [] - for k in range(L): + for _ in range(L): orig_bits.append(x % 2) x = x**2 % public_key

diff --git a/sympy/crypto/tests/test_crypto.py b/sympy/crypto/tests/test_crypto.py index 0ada73f7e513..0711874c361b 100644 --- a/sympy/crypto/tests/test_crypto.py +++ b/sympy/crypto/tests/test_crypto.py @@ -15,7 +15,8 @@ decipher_bifid, bifid_square, padded_key, uniq, decipher_gm, encipher_gm, gm_public_key, gm_private_key, encipher_bg, decipher_bg, bg_private_key, bg_public_key, encipher_rot13, decipher_rot13, - encipher_atbash, decipher_atbash, NonInvertibleCipherWarning) + encipher_atbash, decipher_atbash, NonInvertibleCipherWarning, + encipher_railfence, decipher_railfence) from sympy.matrices import Matrix from sympy.ntheory import isprime, is_primitive_root from sympy.polys.domains import FF @@ -24,6 +25,16 @@ from random import randrange +def test_encipher_railfence(): + assert encipher_railfence("hello world",2) == "hlowrdel ol" + assert encipher_railfence("hello world",3) == "horel ollwd" + assert encipher_railfence("hello world",4) == "hwe olordll" + +def test_decipher_railfence(): + assert decipher_railfence("hlowrdel ol",2) == "hello world" + assert decipher_railfence("horel ollwd",3) == "hello world" + assert decipher_railfence("hwe olordll",4) == "hello world" + def test_cycle_list(): assert cycle_list(3, 4) == [3, 0, 1, 2]

diff --git a/doc/src/modules/crypto.rst b/doc/src/modules/crypto.rst index 14aabee76638..43a916b64797 100644 --- a/doc/src/modules/crypto.rst +++ b/doc/src/modules/crypto.rst @@ -142,3 +142,7 @@ substitutions at different times in the message. .. autofunction:: encipher_gm .. autofunction:: decipher_gm + +.. autofunction:: encipher_railfence + +.. autofunction:: decipher_railfence

[ { "components": [ { "doc": "Performs Railfence Encryption on plaintext and returns ciphertext\n\nExamples\n========\n\n>>> from sympy.crypto.crypto import encipher_railfence\n>>> message = \"hello world\"\n>>> encipher_railfence(message,3)\n'horel ollwd'\n\nParameters\n==========\n\nmessage : stri...

[ "test_encipher_railfence", "test_decipher_railfence", "test_cycle_list", "test_encipher_shift", "test_encipher_rot13", "test_encipher_affine", "test_encipher_atbash", "test_encipher_substitution", "test_check_and_join", "test_encipher_vigenere", "test_decipher_vigenere", "test_encipher_hill", ...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added Rail Fence Cipher  #### References to other Issues or PRs  Closes #15789 Closes #15534 #### Brief description of what is fixed or changed #### Other comments #### Release Notes   * crypto * Rail fence cipher has been added to `sympy.crypto.crypto`  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/crypto/crypto.py] (definition of encipher_railfence:) def encipher_railfence(message,rails): """Performs Railfence Encryption on plaintext and returns ciphertext Examples ======== >>> from sympy.crypto.crypto import encipher_railfence >>> message = "hello world" >>> encipher_railfence(message,3) 'horel ollwd' Parameters ========== message : string, the message to encrypt. rails : int, the number of rails. Returns ======= The Encrypted string message. References ========== .. [1] https://en.wikipedia.org/wiki/Rail_fence_cipher""" (definition of decipher_railfence:) def decipher_railfence(ciphertext,rails): """Decrypt the message using the given rails Examples ======== >>> from sympy.crypto.crypto import decipher_railfence >>> decipher_railfence("horel ollwd",3) 'hello world' Parameters ========== message : string, the message to encrypt. rails : int, the number of rails. Returns ======= The Decrypted string message.""" [end of new definitions in sympy/crypto/crypto.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Added RailFence cipher Updated and Added New RailFence cipher  * crypto * Added railfence cipher  ---------- -------------------- </issues>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-17615

17,615

sympy/sympy

1.5

2d700c4b3c0871a26741456787b0555eed9d5546

2019-09-14T08:32:47Z

diff --git a/sympy/functions/special/gamma_functions.py b/sympy/functions/special/gamma_functions.py index 5a94e17adcc3..a05d3ee6f986 100644 --- a/sympy/functions/special/gamma_functions.py +++ b/sympy/functions/special/gamma_functions.py @@ -992,7 +992,7 @@ def _sage_(self): return sage.log_gamma(self.args[0]._sage_()) -def digamma(x): +class digamma(Function): r""" The digamma function is the first derivative of the loggamma function i.e, @@ -1020,10 +1020,52 @@ def digamma(x): .. [2] http://mathworld.wolfram.com/DigammaFunction.html .. [3] http://functions.wolfram.com/GammaBetaErf/PolyGamma2/ """ - return polygamma(0, x) + def _eval_evalf(self, prec): + z = self.args[0] + return polygamma(0, z).evalf(prec) + + def fdiff(self, argindex=1): + z = self.args[0] + return polygamma(0, z).fdiff() + + def _eval_is_real(self): + z = self.args[0] + return polygamma(0, z).is_real + def _eval_is_positive(self): + z = self.args[0] + return polygamma(0, z).is_positive + + def _eval_is_negative(self): + z = self.args[0] + return polygamma(0, z).is_negative + + def _eval_aseries(self, n, args0, x, logx): + as_polygamma = self.rewrite(polygamma) + args0 = [S.Zero,] + args0 + return as_polygamma._eval_aseries(n, args0, x, logx) -def trigamma(x): + @classmethod + def eval(cls, z): + return polygamma(0, z) + + def _eval_expand_func(self, **hints): + z = self.args[0] + return polygamma(0, z).expand(func=True) + + def _eval_rewrite_as_harmonic(self, z, **kwargs): + return harmonic(z - 1) - S.EulerGamma + + def _eval_rewrite_as_polygamma(self, z, **kwargs): + return polygamma(0, z) + + def _eval_as_leading_term(self, x): + z = self.args[0] + return polygamma(0, z).as_leading_term(x) + + + +class trigamma(Function): r""" The trigamma function is the second derivative of the loggamma function i.e, @@ -1050,7 +1092,52 @@ def trigamma(x): .. [2] http://mathworld.wolfram.com/TrigammaFunction.html .. [3] http://functions.wolfram.com/GammaBetaErf/PolyGamma2/ """ - return polygamma(1, x) + def _eval_evalf(self, prec): + z = self.args[0] + return polygamma(1, z).evalf(prec) + + def fdiff(self, argindex=1): + z = self.args[0] + return polygamma(1, z).fdiff() + + def _eval_is_real(self): + z = self.args[0] + return polygamma(1, z).is_real + + def _eval_is_positive(self): + z = self.args[0] + return polygamma(1, z).is_positive + + def _eval_is_negative(self): + z = self.args[0] + return polygamma(1, z).is_negative + + def _eval_aseries(self, n, args0, x, logx): + as_polygamma = self.rewrite(polygamma) + args0 = [S.One,] + args0 + return as_polygamma._eval_aseries(n, args0, x, logx) + + @classmethod + def eval(cls, z): + return polygamma(1, z) + + def _eval_expand_func(self, **hints): + z = self.args[0] + return polygamma(1, z).expand(func=True) + + def _eval_rewrite_as_zeta(self, z, **kwargs): + return zeta(2, z) + + def _eval_rewrite_as_polygamma(self, z, **kwargs): + return polygamma(1, z) + + def _eval_rewrite_as_harmonic(self, z, **kwargs): + return -harmonic(z - 1, 2) + S.Pi**2 / 6 + + def _eval_as_leading_term(self, x): + z = self.args[0] + return polygamma(1, z).as_leading_term(x) + ############################################################################### ##################### COMPLETE MULTIVARIATE GAMMA FUNCTION ####################

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index a8e3d511bc84..67ee3df3e9f7 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -2288,6 +2288,13 @@ def test_sympy__functions__special__gamma_functions__polygamma(): from sympy.functions.special.gamma_functions import polygamma assert _test_args(polygamma(x, 2)) +def test_sympy__functions__special__gamma_functions__digamma(): + from sympy.functions.special.gamma_functions import digamma + assert _test_args(digamma(x)) + +def test_sympy__functions__special__gamma_functions__trigamma(): + from sympy.functions.special.gamma_functions import trigamma + assert _test_args(trigamma(x)) def test_sympy__functions__special__gamma_functions__uppergamma(): from sympy.functions.special.gamma_functions import uppergamma diff --git a/sympy/functions/special/tests/test_beta_functions.py b/sympy/functions/special/tests/test_beta_functions.py index 3c23ac4e10af..fc19f1ed35d9 100644 --- a/sympy/functions/special/tests/test_beta_functions.py +++ b/sympy/functions/special/tests/test_beta_functions.py @@ -1,4 +1,5 @@ from sympy import (Symbol, gamma, expand_func, beta, digamma, diff, conjugate) +from sympy.functions.special.gamma_functions import polygamma from sympy.core.function import ArgumentIndexError from sympy.utilities.pytest import raises @@ -12,8 +13,8 @@ def test_beta(): assert expand_func(beta(x, y) - beta(y, x)) == 0 # Symmetric assert expand_func(beta(x, y)) == expand_func(beta(x, y + 1) + beta(x + 1, y)).simplify() - assert diff(beta(x, y), x) == beta(x, y)*(digamma(x) - digamma(x + y)) - assert diff(beta(x, y), y) == beta(x, y)*(digamma(y) - digamma(x + y)) + assert diff(beta(x, y), x) == beta(x, y)*(polygamma(0, x) - polygamma(0, x + y)) + assert diff(beta(x, y), y) == beta(x, y)*(polygamma(0, y) - polygamma(0, x + y)) assert conjugate(beta(x, y)) == beta(conjugate(x), conjugate(y)) diff --git a/sympy/functions/special/tests/test_gamma_functions.py b/sympy/functions/special/tests/test_gamma_functions.py index 5acabb14425e..5cc70ea9275b 100644 --- a/sympy/functions/special/tests/test_gamma_functions.py +++ b/sympy/functions/special/tests/test_gamma_functions.py @@ -1,6 +1,6 @@ from sympy import ( Symbol, Dummy, gamma, I, oo, nan, zoo, factorial, sqrt, Rational, - multigamma, log, polygamma, EulerGamma, pi, uppergamma, S, expand_func, + multigamma, log, polygamma, digamma, trigamma, EulerGamma, pi, uppergamma, S, expand_func, loggamma, sin, cos, O, lowergamma, exp, erf, erfc, exp_polar, harmonic, zeta, conjugate, Ei, im, re, tanh, Abs) @@ -114,7 +114,7 @@ def test_lowergamma(): assert td(lowergamma(randcplx(), y), y) assert td(lowergamma(x, randcplx()), x) assert lowergamma(x, y).diff(x) == \ - gamma(x)*polygamma(0, x) - uppergamma(x, y)*log(y) \ + gamma(x)*digamma(x) - uppergamma(x, y)*log(y) \ - meijerg([], [1, 1], [0, 0, x], [], y) assert lowergamma(S.Half, x) == sqrt(pi)*erf(sqrt(x)) @@ -367,6 +367,119 @@ def test_polygamma_expand_func(): e = polygamma(3, x + y + S(3)/4) assert e.expand(func=True, basic=False) == e +def test_digamma(): + from sympy import I + + assert digamma(nan) == nan + + assert digamma(oo) == oo + assert digamma(-oo) == oo + assert digamma(I*oo) == oo + assert digamma(-I*oo) == oo + + assert digamma(-9) == zoo + + assert digamma(-9) == zoo + assert digamma(-1) == zoo + + assert digamma(0) == zoo + + assert digamma(1) == -EulerGamma + assert digamma(7) == Rational(49, 20) - EulerGamma + + def t(m, n): + x = S(m)/n + r = digamma(x) + if r.has(digamma): + return False + return abs(digamma(x.n()).n() - r.n()).n() < 1e-10 + assert t(1, 2) + assert t(3, 2) + assert t(-1, 2) + assert t(1, 4) + assert t(-3, 4) + assert t(1, 3) + assert t(4, 3) + assert t(3, 4) + assert t(2, 3) + assert t(123, 5) + + assert digamma(x).rewrite(zeta) == polygamma(0, x) + + assert digamma(x).rewrite(harmonic) == harmonic(x - 1) - EulerGamma + + assert digamma(I).is_real is None + + assert digamma(x,evaluate=False).fdiff() == polygamma(1, x) + + assert digamma(x,evaluate=False).is_real is None + + assert digamma(x,evaluate=False).is_positive is None + + assert digamma(x,evaluate=False).is_negative is None + + assert digamma(x,evaluate=False).rewrite(polygamma) == polygamma(0, x) + + +def test_digamma_expand_func(): + assert digamma(x).expand(func=True) == polygamma(0, x) + assert digamma(2*x).expand(func=True) == \ + polygamma(0, x)/2 + polygamma(0, Rational(1, 2) + x)/2 + log(2) + assert digamma(-1 + x).expand(func=True) == \ + polygamma(0, x) - 1/(x - 1) + assert digamma(1 + x).expand(func=True) == \ + 1/x + polygamma(0, x ) + assert digamma(2 + x).expand(func=True) == \ + 1/x + 1/(1 + x) + polygamma(0, x) + assert digamma(3 + x).expand(func=True) == \ + polygamma(0, x) + 1/x + 1/(1 + x) + 1/(2 + x) + assert digamma(4 + x).expand(func=True) == \ + polygamma(0, x) + 1/x + 1/(1 + x) + 1/(2 + x) + 1/(3 + x) + assert digamma(x + y).expand(func=True) == \ + polygamma(0, x + y) + +def test_trigamma(): + from sympy import I + + assert trigamma(nan) == nan + + assert trigamma(oo) == 0 + + assert trigamma(1) == pi**2/6 + assert trigamma(2) == pi**2/6 - 1 + assert trigamma(3) == pi**2/6 - Rational(5, 4) + + assert trigamma(x, evaluate=False).rewrite(zeta) == zeta(2, x) + assert trigamma(x, evaluate=False).rewrite(harmonic) == \ + trigamma(x).rewrite(polygamma).rewrite(harmonic) + + assert trigamma(x,evaluate=False).fdiff() == polygamma(2, x) + + assert trigamma(x,evaluate=False).is_real is None + + assert trigamma(x,evaluate=False).is_positive is None + + assert trigamma(x,evaluate=False).is_negative is None + + assert trigamma(x,evaluate=False).rewrite(polygamma) == polygamma(1, x) + +def test_trigamma_expand_func(): + assert trigamma(2*x).expand(func=True) == \ + polygamma(1, x)/4 + polygamma(1, Rational(1, 2) + x)/4 + assert trigamma(1 + x).expand(func=True) == \ + polygamma(1, x) - 1/x**2 + assert trigamma(2 + x).expand(func=True, multinomial=False) == \ + polygamma(1, x) - 1/x**2 - 1/(1 + x)**2 + assert trigamma(3 + x).expand(func=True, multinomial=False) == \ + polygamma(1, x) - 1/x**2 - 1/(1 + x)**2 - 1/(2 + x)**2 + assert trigamma(4 + x).expand(func=True, multinomial=False) == \ + polygamma(1, x) - 1/x**2 - 1/(1 + x)**2 - \ + 1/(2 + x)**2 - 1/(3 + x)**2 + assert trigamma(x + y).expand(func=True) == \ + polygamma(1, x + y) + assert trigamma(3 + 4*x + y).expand(func=True, multinomial=False) == \ + polygamma(1, y + 4*x) - 1/(y + 4*x)**2 - \ + 1/(1 + y + 4*x)**2 - 1/(2 + y + 4*x)**2 def test_loggamma(): raises(TypeError, lambda: loggamma(2, 3))

[ { "components": [ { "doc": "", "lines": [ 1023, 1025 ], "name": "digamma._eval_evalf", "signature": "def _eval_evalf(self, prec):", "type": "function" }, { "doc": "", "lines": [ 1027, 1029 ...

[ "test_digamma", "test_trigamma" ]

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Implement digamma and trigamma functions as Function subclasses  #### References to other Issues or PRs  Fixes #17596 #### Brief description of what is fixed or changed The digamma and trigamma functions were Python functions. Now they are Function subclasses #### Other comments Added tests for digamma and trigamma #### Release Notes   * functions * made digamma and trigamma into Function subclasses  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/functions/special/gamma_functions.py] (definition of digamma._eval_evalf:) def _eval_evalf(self, prec): (definition of digamma.fdiff:) def fdiff(self, argindex=1): (definition of digamma._eval_is_real:) def _eval_is_real(self): (definition of digamma._eval_is_positive:) def _eval_is_positive(self): (definition of digamma._eval_is_negative:) def _eval_is_negative(self): (definition of digamma._eval_aseries:) def _eval_aseries(self, n, args0, x, logx): (definition of digamma.eval:) def eval(cls, z): (definition of digamma._eval_expand_func:) def _eval_expand_func(self, **hints): (definition of digamma._eval_rewrite_as_harmonic:) def _eval_rewrite_as_harmonic(self, z, **kwargs): (definition of digamma._eval_rewrite_as_polygamma:) def _eval_rewrite_as_polygamma(self, z, **kwargs): (definition of digamma._eval_as_leading_term:) def _eval_as_leading_term(self, x): (definition of trigamma._eval_evalf:) def _eval_evalf(self, prec): (definition of trigamma.fdiff:) def fdiff(self, argindex=1): (definition of trigamma._eval_is_real:) def _eval_is_real(self): (definition of trigamma._eval_is_positive:) def _eval_is_positive(self): (definition of trigamma._eval_is_negative:) def _eval_is_negative(self): (definition of trigamma._eval_aseries:) def _eval_aseries(self, n, args0, x, logx): (definition of trigamma.eval:) def eval(cls, z): (definition of trigamma._eval_expand_func:) def _eval_expand_func(self, **hints): (definition of trigamma._eval_rewrite_as_zeta:) def _eval_rewrite_as_zeta(self, z, **kwargs): (definition of trigamma._eval_rewrite_as_polygamma:) def _eval_rewrite_as_polygamma(self, z, **kwargs): (definition of trigamma._eval_rewrite_as_harmonic:) def _eval_rewrite_as_harmonic(self, z, **kwargs): (definition of trigamma._eval_as_leading_term:) def _eval_as_leading_term(self, x): [end of new definitions in sympy/functions/special/gamma_functions.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> digamma and trigamma should be Function subclasses Right now `digamma` and `trigamma` are Python functions. They should be Function subclasses, so they can be unevaluated. ---------- I'd like to work on this issue. -------------------- </issues>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-17581

17,581

sympy/sympy

1.5

f5e965947af2410ded92cfad987aaf45262ea434

2019-09-05T19:19:27Z

diff --git a/doc/src/modules/sets.rst b/doc/src/modules/sets.rst index 35a8a8910eb9..d87a4b2f3bdf 100644 --- a/doc/src/modules/sets.rst +++ b/doc/src/modules/sets.rst @@ -2,6 +2,9 @@ Sets ==== +Basic Sets +---------- + .. automodule:: sympy.sets.sets Set @@ -24,8 +27,20 @@ FiniteSet .. autoclass:: FiniteSet :members: +ConditionSet +^^^^^^^^^^^^ +.. module:: sympy.sets.conditionset + :noindex: + +.. autoclass:: ConditionSet + :members: + Compound Sets ------------- + +.. module:: sympy.sets.sets + :noindex: + Union ^^^^^ .. autoclass:: Union @@ -46,6 +61,11 @@ Complement .. autoclass:: Complement :members: +SymmetricDifference +^^^^^^^^^^^^^^^^^^^ +.. autoclass:: SymmetricDifference + :members: + Singleton Sets -------------- @@ -95,6 +115,16 @@ ComplexRegion .. autofunction:: normalize_theta_set +Power sets +---------- + +.. automodule:: sympy.sets.powerset + +PowerSet +^^^^^^^^ +.. autoclass:: PowerSet + :members: + Iteration over sets ^^^^^^^^^^^^^^^^^^^ diff --git a/sympy/sets/__init__.py b/sympy/sets/__init__.py index a66ce07138aa..c3c400e9ae84 100644 --- a/sympy/sets/__init__.py +++ b/sympy/sets/__init__.py @@ -4,6 +4,7 @@ from .contains import Contains from .conditionset import ConditionSet from .ordinals import Ordinal, OmegaPower, ord0 +from .powerset import PowerSet from ..core.singleton import S Reals = S.Reals Naturals = S.Naturals diff --git a/sympy/sets/powerset.py b/sympy/sets/powerset.py new file mode 100644 index 000000000000..3722f5da35ca --- /dev/null +++ b/sympy/sets/powerset.py @@ -0,0 +1,116 @@ +from __future__ import print_function, division + +from sympy.core.decorators import _sympifyit +from sympy.core.evaluate import global_evaluate +from sympy.core.logic import fuzzy_bool +from sympy.core.singleton import S +from sympy.core.sympify import _sympify + +from .sets import Set, tfn + + +class PowerSet(Set): + r"""A symbolic object representing a power set. + + Parameters + ========== + + arg : Set + The set to take power of. + + evaluate : bool + The flag to control evaluation. + + If the evaluation is disabled for finite sets, it can take + advantage of using subset test as a membership test. + + Notes + ===== + + Power set `\mathcal{P}(S)` is defined as a set containing all the + subsets of `S`. + + If the set `S` is a finite set, its power set would have + `2^{\left| S \right|}` elements, where `\left| S \right|` denotes + the cardinality of `S`. + + Examples + ======== + + >>> from sympy.sets.powerset import PowerSet + >>> from sympy import S, FiniteSet + + A power set of a finite set: + + >>> PowerSet(FiniteSet(1, 2, 3)) + PowerSet({1, 2, 3}) + + A power set of an empty set: + + >>> PowerSet(S.EmptySet) + PowerSet(EmptySet()) + >>> PowerSet(PowerSet(S.EmptySet)) + PowerSet(PowerSet(EmptySet())) + + A power set of an infinite set: + + >>> PowerSet(S.Reals) + PowerSet(Reals) + + Evaluating the power set of a finite set to its explicit form: + + >>> PowerSet(FiniteSet(1, 2, 3)).rewrite(FiniteSet) + {EmptySet(), {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}} + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Power_set + + .. [2] https://en.wikipedia.org/wiki/Axiom_of_power_set + """ + def __new__(cls, arg, evaluate=global_evaluate[0]): + arg = _sympify(arg) + + if not isinstance(arg, Set): + raise ValueError('{} must be a set.'.format(arg)) + + return super(PowerSet, cls).__new__(cls, arg) + + @property + def arg(self): + return self.args[0] + + def _eval_rewrite_as_FiniteSet(self, *args, **kwargs): + arg = self.arg + if arg.is_FiniteSet: + return arg.powerset() + return None + + @_sympifyit('other', NotImplemented) + def _contains(self, other): + if not isinstance(other, Set): + return None + + return fuzzy_bool(self.arg.is_superset(other)) + + def _eval_is_subset(self, other): + if isinstance(other, PowerSet): + return self.arg.is_subset(other.arg) + + def __len__(self): + return 2 ** len(self.arg) + + def __iter__(self): + from .sets import FiniteSet + found = [S.EmptySet] + yield S.EmptySet + + for x in self.arg: + temp = [] + x = FiniteSet(x) + for y in found: + new = x + y + yield new + temp.append(new) + found.extend(temp) diff --git a/sympy/sets/sets.py b/sympy/sets/sets.py index ef8a957043df..d609dcc04ab8 100644 --- a/sympy/sets/sets.py +++ b/sympy/sets/sets.py @@ -366,6 +366,12 @@ def is_subset(self, other): """ if isinstance(other, Set): + dispatch = getattr(self, '_eval_is_subset', None) + if dispatch is not None: + ret = dispatch(other) + if ret is not None: + return ret + s_o = self.intersect(other) if s_o == self: return True @@ -448,7 +454,7 @@ def is_proper_superset(self, other): raise ValueError("Unknown argument '%s'" % other) def _eval_powerset(self): - raise NotImplementedError('Power set not defined for: %s' % self.func) + return None def powerset(self): """ @@ -1832,6 +1838,25 @@ def _sorted_args(self): def _eval_powerset(self): return self.func(*[self.func(*s) for s in subsets(self.args)]) + def _eval_rewrite_as_PowerSet(self, *args, **kwargs): + """Rewriting method for a finite set to a power set.""" + from .powerset import PowerSet + + is2pow = lambda n: bool(n and not n & (n - 1)) + if not is2pow(len(self)): + return None + + fs_test = lambda arg: isinstance(arg, Set) and arg.is_FiniteSet + if not all((fs_test(arg) for arg in args)): + return None + + biggest = max(args, key=len) + for arg in subsets(biggest.args): + arg_set = FiniteSet(*arg) + if arg_set not in args: + return None + return PowerSet(biggest) + def __ge__(self, other): if not isinstance(other, Set): raise TypeError("Invalid comparison of set with %s" % func_name(other))

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 3373c913ab74..5171802bf931 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -823,6 +823,13 @@ def test_sympy__sets__ordinals__OrdinalZero(): from sympy.sets.ordinals import OrdinalZero assert _test_args(OrdinalZero()) + +def test_sympy__sets__powerset__PowerSet(): + from sympy.sets.powerset import PowerSet + from sympy.core.singleton import S + assert _test_args(PowerSet(S.EmptySet)) + + def test_sympy__sets__sets__EmptySet(): from sympy.sets.sets import EmptySet assert _test_args(EmptySet()) diff --git a/sympy/sets/tests/test_powerset.py b/sympy/sets/tests/test_powerset.py new file mode 100644 index 000000000000..2091af405254 --- /dev/null +++ b/sympy/sets/tests/test_powerset.py @@ -0,0 +1,116 @@ +from sympy.core.expr import unchanged +from sympy.core.singleton import S +from sympy.core.symbol import Symbol +from sympy.sets.contains import Contains +from sympy.sets.powerset import PowerSet +from sympy.sets.sets import FiniteSet +from sympy.utilities.pytest import raises, XFAIL + + +def test_powerset_creation(): + assert unchanged(PowerSet, FiniteSet(1, 2)) + assert unchanged(PowerSet, S.EmptySet) + raises(ValueError, lambda: PowerSet(123)) + assert unchanged(PowerSet, S.Reals) + assert unchanged(PowerSet, S.Integers) + + +def test_powerset_rewrite_FiniteSet(): + assert PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet) == \ + FiniteSet(S.EmptySet, FiniteSet(1), FiniteSet(2), FiniteSet(1, 2)) + assert PowerSet(S.EmptySet).rewrite(FiniteSet) == FiniteSet(S.EmptySet) + assert PowerSet(S.Naturals).rewrite(FiniteSet) == PowerSet(S.Naturals) + + +def test_finiteset_rewrite_powerset(): + assert FiniteSet(S.EmptySet).rewrite(PowerSet) == PowerSet(S.EmptySet) + assert FiniteSet( + S.EmptySet, FiniteSet(1), + FiniteSet(2), FiniteSet(1, 2)).rewrite(PowerSet) == \ + PowerSet(FiniteSet(1, 2)) + assert FiniteSet(1, 2, 3).rewrite(PowerSet) == FiniteSet(1, 2, 3) + + +def test_powerset__contains__(): + subset_series = [ + S.EmptySet, + FiniteSet(1, 2), + S.Naturals, + S.Naturals0, + S.Integers, + S.Rationals, + S.Reals, + S.Complexes] + + l = len(subset_series) + for i in range(l): + for j in range(l): + try: + if i <= j: + assert subset_series[i] in \ + PowerSet(subset_series[j], evaluate=False) + else: + assert subset_series[i] not in \ + PowerSet(subset_series[j], evaluate=False) + except: + raise AssertionError( + 'Powerset membership test failed between ' + '{} and {}.'.format(subset_series[i], subset_series[j])) + + +@XFAIL +def test_failing_powerset__contains__(): + # XXX These are failing when evaluate=True, + # but using unevaluated PowerSet works fine. + assert FiniteSet(1, 2) not in PowerSet(S.EmptySet).rewrite(FiniteSet) + assert S.Naturals not in PowerSet(S.EmptySet).rewrite(FiniteSet) + assert S.Naturals not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet) + assert S.Naturals0 not in PowerSet(S.EmptySet).rewrite(FiniteSet) + assert S.Naturals0 not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet) + assert S.Integers not in PowerSet(S.EmptySet).rewrite(FiniteSet) + assert S.Integers not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet) + assert S.Rationals not in PowerSet(S.EmptySet).rewrite(FiniteSet) + assert S.Rationals not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet) + assert S.Reals not in PowerSet(S.EmptySet).rewrite(FiniteSet) + assert S.Reals not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet) + assert S.Complexes not in PowerSet(S.EmptySet).rewrite(FiniteSet) + assert S.Complexes not in PowerSet(FiniteSet(1, 2)).rewrite(FiniteSet) + + +def test_powerset__len__(): + A = PowerSet(S.EmptySet, evaluate=False) + assert len(A) == 1 + A = PowerSet(A, evaluate=False) + assert len(A) == 2 + A = PowerSet(A, evaluate=False) + assert len(A) == 4 + A = PowerSet(A, evaluate=False) + assert len(A) == 16 + + +def test_powerset__iter__(): + a = PowerSet(FiniteSet(1, 2)).__iter__() + assert next(a) == S.EmptySet + assert next(a) == FiniteSet(1) + assert next(a) == FiniteSet(2) + assert next(a) == FiniteSet(1, 2) + + a = PowerSet(S.Naturals).__iter__() + assert next(a) == S.EmptySet + assert next(a) == FiniteSet(1) + assert next(a) == FiniteSet(2) + assert next(a) == FiniteSet(1, 2) + assert next(a) == FiniteSet(3) + assert next(a) == FiniteSet(1, 3) + assert next(a) == FiniteSet(2, 3) + assert next(a) == FiniteSet(1, 2, 3) + + +def test_powerset_contains(): + A = PowerSet(FiniteSet(1), evaluate=False) + assert A.contains(2) == Contains(2, A) + + x = Symbol('x') + + A = PowerSet(FiniteSet(x), evaluate=False) + assert A.contains(FiniteSet(1)) == Contains(FiniteSet(1), A) diff --git a/sympy/sets/tests/test_sets.py b/sympy/sets/tests/test_sets.py index 014597828bcc..8afd13c59fd2 100644 --- a/sympy/sets/tests/test_sets.py +++ b/sympy/sets/tests/test_sets.py @@ -892,7 +892,6 @@ def test_powerset(): FiniteSet(2), A) # Not finite sets I = Interval(0, 1) - raises(NotImplementedError, I.powerset) def test_product_basic():

diff --git a/doc/src/modules/sets.rst b/doc/src/modules/sets.rst index 35a8a8910eb9..d87a4b2f3bdf 100644 --- a/doc/src/modules/sets.rst +++ b/doc/src/modules/sets.rst @@ -2,6 +2,9 @@ Sets ==== +Basic Sets +---------- + .. automodule:: sympy.sets.sets Set @@ -24,8 +27,20 @@ FiniteSet .. autoclass:: FiniteSet :members: +ConditionSet +^^^^^^^^^^^^ +.. module:: sympy.sets.conditionset + :noindex: + +.. autoclass:: ConditionSet + :members: + Compound Sets ------------- + +.. module:: sympy.sets.sets + :noindex: + Union ^^^^^ .. autoclass:: Union @@ -46,6 +61,11 @@ Complement .. autoclass:: Complement :members: +SymmetricDifference +^^^^^^^^^^^^^^^^^^^ +.. autoclass:: SymmetricDifference + :members: + Singleton Sets -------------- @@ -95,6 +115,16 @@ ComplexRegion .. autofunction:: normalize_theta_set +Power sets +---------- + +.. automodule:: sympy.sets.powerset + +PowerSet +^^^^^^^^ +.. autoclass:: PowerSet + :members: + Iteration over sets ^^^^^^^^^^^^^^^^^^^

[ { "components": [ { "doc": "A symbolic object representing a power set.\n\nParameters\n==========\n\narg : Set\n The set to take power of.\n\nevaluate : bool\n The flag to control evaluation.\n\n If the evaluation is disabled for finite sets, it can take\n advantage of using subset tes...

[ "test_sympy__sets__powerset__PowerSet", "test_powerset_creation", "test_powerset_rewrite_FiniteSet", "test_finiteset_rewrite_powerset", "test_powerset__contains__", "test_powerset__len__", "test_powerset__iter__" ]

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add power set notation  #### References to other Issues or PRs  #### Brief description of what is fixed or changed The previous implementation in #7329 have some limitations that it can only be applicable for finite sets, and generally, computation can be slow even for a handful of elements. I've added a full symbolic representation to resolve such issues. I also think that using powerset can resolve failings like `FiniteSet(1, 2) not in FiniteSet(S.EmptySet)` because it can use subset testing for membership testing. #### Other comments I've also fixed the rst section ordering, added missing docs for some other set classes. The doc for the PowerSet would look like ![image](https://user-images.githubusercontent.com/34944973/64371749-50a3ee00-d05c-11e9-93b5-1965085ba1d0.png) #### Release Notes   - sets - Added `PowerSet` for representing symbolic power set. - Fixed table-of-contents in the set documentation. - Added missing documentation about `SymmetricDifference`, `ConditionSet`.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/sets/powerset.py] (definition of PowerSet:) class PowerSet(Set): """A symbolic object representing a power set. Parameters ========== arg : Set The set to take power of. evaluate : bool The flag to control evaluation. If the evaluation is disabled for finite sets, it can take advantage of using subset test as a membership test. Notes ===== Power set `\mathcal{P}(S)` is defined as a set containing all the subsets of `S`. If the set `S` is a finite set, its power set would have `2^{\left| S \right|}` elements, where `\left| S \right|` denotes the cardinality of `S`. Examples ======== >>> from sympy.sets.powerset import PowerSet >>> from sympy import S, FiniteSet A power set of a finite set: >>> PowerSet(FiniteSet(1, 2, 3)) PowerSet({1, 2, 3}) A power set of an empty set: >>> PowerSet(S.EmptySet) PowerSet(EmptySet()) >>> PowerSet(PowerSet(S.EmptySet)) PowerSet(PowerSet(EmptySet())) A power set of an infinite set: >>> PowerSet(S.Reals) PowerSet(Reals) Evaluating the power set of a finite set to its explicit form: >>> PowerSet(FiniteSet(1, 2, 3)).rewrite(FiniteSet) {EmptySet(), {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}} References ========== .. [1] https://en.wikipedia.org/wiki/Power_set .. [2] https://en.wikipedia.org/wiki/Axiom_of_power_set""" (definition of PowerSet.__new__:) def __new__(cls, arg, evaluate=global_evaluate[0]): (definition of PowerSet.arg:) def arg(self): (definition of PowerSet._eval_rewrite_as_FiniteSet:) def _eval_rewrite_as_FiniteSet(self, *args, **kwargs): (definition of PowerSet._contains:) def _contains(self, other): (definition of PowerSet._eval_is_subset:) def _eval_is_subset(self, other): (definition of PowerSet.__len__:) def __len__(self): (definition of PowerSet.__iter__:) def __iter__(self): [end of new definitions in sympy/sets/powerset.py] [start of new definitions in sympy/sets/sets.py] (definition of FiniteSet._eval_rewrite_as_PowerSet:) def _eval_rewrite_as_PowerSet(self, *args, **kwargs): """Rewriting method for a finite set to a power set.""" [end of new definitions in sympy/sets/sets.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

rytilahti__python-miio-544

544

rytilahti/python-miio

null

7df68214bf2008e7bb30100d93c3f8c61183daf7

2019-09-02T09:03:19Z

diff --git a/README.rst b/README.rst index 74e3888de..2d7270df1 100644 --- a/README.rst +++ b/README.rst @@ -34,6 +34,7 @@ Supported devices - Xiaomi Smartmi Fresh Air System (:class:`miio.airfresh`) - :doc:`Yeelight light bulbs <yeelight>` (:class:`miio.yeelight`) (only a very rudimentary support, use `python-yeelight <https://gitlab.com/stavros/python-yeelight/>`__ for a more complete support) - Xiaomi Mi Air Dehumidifier (:class:`miio.airdehumidifier`) +- Xiaomi Tinymu Smart Toilet Cover (:class:`miio.toiletlid`) - Xiaomi 16 Relays Module (:class:`miio.pwzn_relay`) *Feel free to create a pull request to add support for new devices as diff --git a/miio/__init__.py b/miio/__init__.py index 7941d43cc..d9489f0d1 100644 --- a/miio/__init__.py +++ b/miio/__init__.py @@ -18,6 +18,7 @@ from miio.philips_moonlight import PhilipsMoonlight from miio.powerstrip import PowerStrip from miio.protocol import Message, Utils +from miio.toiletlid import Toiletlid from miio.pwzn_relay import PwznRelay from miio.vacuum import Vacuum, VacuumException from miio.vacuumcontainers import (VacuumStatus, ConsumableStatus, DNDStatus, diff --git a/miio/discovery.py b/miio/discovery.py index 9f9e97e2d..afce254d7 100644 --- a/miio/discovery.py +++ b/miio/discovery.py @@ -10,7 +10,8 @@ from . import (Device, Vacuum, ChuangmiCamera, ChuangmiPlug, PowerStrip, AirPurifier, AirFresh, Ceil, PhilipsBulb, PhilipsEyecare, PhilipsMoonlight, ChuangmiIr, AirHumidifier, WaterPurifier, WifiSpeaker, WifiRepeater, - Yeelight, Fan, Cooker, AirConditioningCompanion, AirQualityMonitor, AqaraCamera) + Yeelight, Fan, Cooker, AirConditioningCompanion, AirQualityMonitor, AqaraCamera, + Toiletlid) from .airconditioningcompanion import (MODEL_ACPARTNER_V1, MODEL_ACPARTNER_V2, MODEL_ACPARTNER_V3, ) from .airqualitymonitor import (MODEL_AIRQUALITYMONITOR_V1, MODEL_AIRQUALITYMONITOR_B1, @@ -23,6 +24,7 @@ from .fan import (MODEL_FAN_V2, MODEL_FAN_V3, MODEL_FAN_SA1, MODEL_FAN_ZA1, MODEL_FAN_ZA3, MODEL_FAN_ZA4, MODEL_FAN_P5, ) from .powerstrip import (MODEL_POWER_STRIP_V1, MODEL_POWER_STRIP_V2, ) +from .toiletlid import (MODEL_TOILETLID_V1, ) _LOGGER = logging.getLogger(__name__) @@ -89,6 +91,7 @@ "zhimi-fan-za3": partial(Fan, model=MODEL_FAN_ZA3), "zhimi-fan-za4": partial(Fan, model=MODEL_FAN_ZA4), "dmaker-fan-p5": partial(Fan, model=MODEL_FAN_P5), + "tinymu-toiletlid-v1": partial(Toiletlid, model=MODEL_TOILETLID_V1), "zhimi-airfresh-va2": AirFresh, "zhimi-airmonitor-v1": partial(AirQualityMonitor, model=MODEL_AIRQUALITYMONITOR_V1), "cgllc-airmonitor-b1": partial(AirQualityMonitor, model=MODEL_AIRQUALITYMONITOR_B1), diff --git a/miio/toiletlid.py b/miio/toiletlid.py new file mode 100644 index 000000000..84b08c66b --- /dev/null +++ b/miio/toiletlid.py @@ -0,0 +1,144 @@ +import enum +import logging +from typing import Any, Dict + +import click + +from .click_common import command, format_output, EnumType +from .device import Device + +_LOGGER = logging.getLogger(__name__) + +MODEL_TOILETLID_V1 = "tinymu.toiletlid.v1" + +AVAILABLE_PROPERTIES_COMMON = ["work_state", "filter_use_flux", "filter_use_time"] + +AVAILABLE_PROPERTIES = {MODEL_TOILETLID_V1: AVAILABLE_PROPERTIES_COMMON} + + +class AmbientLightColor(enum.Enum): + White = "0" + Yellow = "1" + Powder = "2" + Green = "3" + Purple = "4" + Blue = "5" + Orange = "6" + Red = "7" + + +class ToiletlidStatus: + def __init__(self, data: Dict[str, Any]) -> None: + # {"work_state": 1,"filter_use_flux": 100,"filter_use_time": 180, "ambient_light": "Red"} + self.data = data + + @property + def work_state(self) -> int: + """Device state code""" + return self.data["work_state"] + + @property + def is_on(self) -> bool: + return self.work_state != 1 + + @property + def filter_use_percentage(self) -> str: + """Filter percentage of remaining life""" + return "{}%".format(self.data["filter_use_flux"]) + + @property + def filter_remaining_time(self) -> int: + """Filter remaining life days""" + return self.data["filter_use_time"] + + @property + def ambient_light(self) -> str: + """Ambient light color.""" + return self.data["ambient_light"] + + def __repr__(self) -> str: + return ( + "<ToiletlidStatus work=%s, " + "state=%s, " + "ambient_light=%s, " + "filter_use_percentage=%s, " + "filter_remaining_time=%s>" + % ( + self.is_on, + self.work_state, + self.ambient_light, + self.filter_use_percentage, + self.filter_remaining_time, + ) + ) + + +class Toiletlid(Device): + def __init__( + self, + ip: str = None, + token: str = None, + start_id: int = 0, + debug: int = 0, + lazy_discover: bool = True, + model: str = MODEL_TOILETLID_V1, + ) -> None: + super().__init__(ip, token, start_id, debug, lazy_discover) + + if model in AVAILABLE_PROPERTIES: + self.model = model + else: + self.model = MODEL_TOILETLID_V1 + + @command( + default_output=format_output( + "", + "Work: {result.is_on}\n" + "State: {result.work_state}\n" + "Ambient Light: {result.ambient_light}\n" + "Filter remaining: {result.filter_use_percentage}\n" + "Filter remaining time: {result.filter_remaining_time}\n", + ) + ) + def status(self) -> ToiletlidStatus: + """Retrieve properties.""" + properties = AVAILABLE_PROPERTIES[self.model] + values = self.send("get_prop", properties) + properties_count = len(properties) + values_count = len(values) + if properties_count != values_count: + _LOGGER.error( + "Count (%s) of requested properties does not match the " + "count (%s) of received values.", + properties_count, + values_count, + ) + color = self.get_ambient_light() + return ToiletlidStatus(dict(zip(properties, values), ambient_light=color)) + + @command(default_output=format_output("Nozzle clean")) + def nozzle_clean(self): + """Nozzle clean.""" + return self.send("nozzle_clean", ["on"]) + + @command( + click.argument("color", type=EnumType(AmbientLightColor, False)), + default_output=format_output( + "Set the ambient light to {color} color the next time you start it." + ), + ) + def set_ambient_light(self, color: AmbientLightColor): + """Set Ambient light color.""" + return self.send("set_aled_v_of_uid", ["", color.value]) + + @command(default_output=format_output("Get the Ambient light color.")) + def get_ambient_light(self) -> str: + """Get Ambient light color.""" + color = self.send("get_aled_v_of_uid", [""]) + try: + return AmbientLightColor(color[0]).name + except ValueError: + _LOGGER.warning( + "Get ambient light response error, return unknown value: %s.", color[0] + ) + return "Unknown"

diff --git a/miio/tests/test_toiletlid.py b/miio/tests/test_toiletlid.py new file mode 100644 index 000000000..68f3af149 --- /dev/null +++ b/miio/tests/test_toiletlid.py @@ -0,0 +1,94 @@ +from unittest import TestCase + +import pytest + +from miio.toiletlid import ( + Toiletlid, + ToiletlidStatus, + AmbientLightColor, + MODEL_TOILETLID_V1, +) +from .dummies import DummyDevice + +""" +Response instance +>> status + +Work: False +State: 1 +Ambient Light: Yellow +Filter remaining: 100% +Filter remaining time: 180 +""" + + +class DummyToiletlidV1(DummyDevice, Toiletlid): + def __init__(self, *args, **kwargs): + self.model = MODEL_TOILETLID_V1 + self.state = { + "is_on": False, + "work_state": 1, + "ambient_light": "Yellow", + "filter_use_flux": "100", + "filter_use_time": "180", + } + + self.return_values = { + "get_prop": self._get_state, + "nozzle_clean": lambda x: self._set_state("work_state", [97]), + "set_aled_v_of_uid": self.set_aled_v_of_uid, + "get_aled_v_of_uid": self.get_aled_v_of_uid, + } + super().__init__(args, kwargs) + + def set_aled_v_of_uid(self, x): + uid, color = x + return self._set_state("ambient_light", [AmbientLightColor(color).name]) + + def get_aled_v_of_uid(self, uid): + color = self._get_state(["ambient_light"]) + if not AmbientLightColor._member_map_.get(color[0]): + raise ValueError(color) + return AmbientLightColor._member_map_.get(color[0]).value + + +@pytest.fixture(scope="class") +def toiletlidv1(request): + request.cls.device = DummyToiletlidV1() + # TODO add ability to test on a real device + + +@pytest.mark.usefixtures("toiletlidv1") +class TestToiletlidV1(TestCase): + def is_on(self): + return self.device.status().is_on + + def state(self): + return self.device.status() + + def test_status(self): + self.device._reset_state() + + assert repr(self.state()) == repr(ToiletlidStatus(self.device.start_state)) + + assert self.is_on() is False + assert self.state().work_state == self.device.start_state["work_state"] + assert self.state().ambient_light == self.device.start_state["ambient_light"] + assert ( + self.state().filter_use_percentage + == "%s%%" % self.device.start_state["filter_use_flux"] + ) + assert ( + self.state().filter_remaining_time + == self.device.start_state["filter_use_time"] + ) + + def test_set_ambient_light(self): + for value, enum in AmbientLightColor._member_map_.items(): + self.device.set_ambient_light(enum) + assert self.device.status().ambient_light == value + + def test_nozzle_clean(self): + self.device.nozzle_clean() + assert self.is_on() is True + self.device._reset_state()

diff --git a/README.rst b/README.rst index 74e3888de..2d7270df1 100644 --- a/README.rst +++ b/README.rst @@ -34,6 +34,7 @@ Supported devices - Xiaomi Smartmi Fresh Air System (:class:`miio.airfresh`) - :doc:`Yeelight light bulbs <yeelight>` (:class:`miio.yeelight`) (only a very rudimentary support, use `python-yeelight <https://gitlab.com/stavros/python-yeelight/>`__ for a more complete support) - Xiaomi Mi Air Dehumidifier (:class:`miio.airdehumidifier`) +- Xiaomi Tinymu Smart Toilet Cover (:class:`miio.toiletlid`) - Xiaomi 16 Relays Module (:class:`miio.pwzn_relay`) *Feel free to create a pull request to add support for new devices as

[ { "components": [ { "doc": "", "lines": [ 19, 27 ], "name": "AmbientLightColor", "signature": "class AmbientLightColor(enum.Enum):", "type": "class" }, { "doc": "", "lines": [ 30, 71 ...

[ "miio/tests/test_toiletlid.py::TestToiletlidV1::test_nozzle_clean", "miio/tests/test_toiletlid.py::TestToiletlidV1::test_set_ambient_light", "miio/tests/test_toiletlid.py::TestToiletlidV1::test_status" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add tinymu smart toiletlid # select toiletlid status Work: False State: 1 Ambient Light: White Filter remaining: 100% Filter remaining time: 180 # set toiletlid ambient light Support color: blue green orange powder purple red white yellow # nozzle clean ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in miio/toiletlid.py] (definition of AmbientLightColor:) class AmbientLightColor(enum.Enum): (definition of ToiletlidStatus:) class ToiletlidStatus: (definition of ToiletlidStatus.__init__:) def __init__(self, data: Dict[str, Any]) -> None: (definition of ToiletlidStatus.work_state:) def work_state(self) -> int: """Device state code""" (definition of ToiletlidStatus.is_on:) def is_on(self) -> bool: (definition of ToiletlidStatus.filter_use_percentage:) def filter_use_percentage(self) -> str: """Filter percentage of remaining life""" (definition of ToiletlidStatus.filter_remaining_time:) def filter_remaining_time(self) -> int: """Filter remaining life days""" (definition of ToiletlidStatus.ambient_light:) def ambient_light(self) -> str: """Ambient light color.""" (definition of ToiletlidStatus.__repr__:) def __repr__(self) -> str: (definition of Toiletlid:) class Toiletlid(Device): (definition of Toiletlid.__init__:) def __init__( self, ip: str = None, token: str = None, start_id: int = 0, debug: int = 0, lazy_discover: bool = True, model: str = MODEL_TOILETLID_V1, ) -> None: (definition of Toiletlid.status:) def status(self) -> ToiletlidStatus: """Retrieve properties.""" (definition of Toiletlid.nozzle_clean:) def nozzle_clean(self): """Nozzle clean.""" (definition of Toiletlid.set_ambient_light:) def set_ambient_light(self, color: AmbientLightColor): """Set Ambient light color.""" (definition of Toiletlid.get_ambient_light:) def get_ambient_light(self) -> str: """Get Ambient light color.""" [end of new definitions in miio/toiletlid.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

62427d2f796e603520acca3b57b29ec3e6489bca

RDFLib__rdflib-931

931

RDFLib/rdflib

null

827eabd437e0a0b4404559b6acacdf696f700593

2019-08-31T14:14:02Z

diff --git a/rdflib/graph.py b/rdflib/graph.py index 80dc02f80..a92f3bc58 100644 --- a/rdflib/graph.py +++ b/rdflib/graph.py @@ -271,6 +271,7 @@ "Dataset", "UnSupportedAggregateOperation", "ReadOnlyGraphAggregate", + "BatchAddGraph", ] @@ -2013,6 +2014,73 @@ def _assertnode(*terms): return True +class BatchAddGraph(object): + ''' + Wrapper around graph that turns calls to :meth:`add` (and optionally, :meth:`addN`) + into calls to :meth:`~rdflib.graph.Graph.addN`. + + :Parameters: + + - `graph`: The graph to wrap + - `batch_size`: The maximum number of triples to buffer before passing to + `graph`'s `addN` + - `batch_addn`: If True, then even calls to `addN` will be batched according to + `batch_size` + + :ivar graph: The wrapped graph + :ivar count: The number of triples buffered since initaialization or the last call + to :meth:`reset` + :ivar batch: The current buffer of triples + + ''' + + def __init__(self, graph, batch_size=1000, batch_addn=False): + if not batch_size or batch_size < 2: + raise ValueError("batch_size must be a positive number") + self.graph = graph + self.__graph_tuple = (graph,) + self.__batch_size = batch_size + self.__batch_addn = batch_addn + self.reset() + + def reset(self): + ''' + Manually clear the buffered triples and reset the count to zero + ''' + self.batch = [] + self.count = 0 + + def add(self, triple_or_quad): + ''' + Add a triple to the buffer + + :param triple: The triple to add + ''' + if len(self.batch) >= self.__batch_size: + self.graph.addN(self.batch) + self.batch = [] + self.count += 1 + if len(triple_or_quad) == 3: + self.batch.append(triple_or_quad + self.__graph_tuple) + else: + self.batch.append(triple_or_quad) + + def addN(self, quads): + if self.__batch_addn: + for q in quads: + self.add(q) + else: + self.graph.addN(quads) + + def __enter__(self): + self.reset() + return self + + def __exit__(self, *exc): + if exc[0] is None: + self.graph.addN(self.batch) + + def test(): import doctest

diff --git a/test/test_batch_add.py b/test/test_batch_add.py new file mode 100644 index 000000000..1747100ca --- /dev/null +++ b/test/test_batch_add.py @@ -0,0 +1,89 @@ +import unittest +from rdflib.graph import Graph, BatchAddGraph +from rdflib.term import URIRef + + +class TestBatchAddGraph(unittest.TestCase): + def test_batch_size_zero_denied(self): + with self.assertRaises(ValueError): + BatchAddGraph(Graph(), batch_size=0) + + def test_batch_size_none_denied(self): + with self.assertRaises(ValueError): + BatchAddGraph(Graph(), batch_size=None) + + def test_batch_size_one_denied(self): + with self.assertRaises(ValueError): + BatchAddGraph(Graph(), batch_size=1) + + def test_batch_size_negative_denied(self): + with self.assertRaises(ValueError): + BatchAddGraph(Graph(), batch_size=-12) + + def test_exit_submits_partial_batch(self): + trip = (URIRef('a'), URIRef('b'), URIRef('c')) + g = Graph() + with BatchAddGraph(g, batch_size=10) as cut: + cut.add(trip) + self.assertIn(trip, g) + + def test_add_more_than_batch_size(self): + trips = [(URIRef('a'), URIRef('b%d' % i), URIRef('c%d' % i)) + for i in range(12)] + g = Graph() + with BatchAddGraph(g, batch_size=10) as cut: + for trip in trips: + cut.add(trip) + self.assertEqual(12, len(g)) + + def test_add_quad_for_non_conjunctive_empty(self): + ''' + Graph drops quads that don't match our graph. Make sure we do the same + ''' + g = Graph(identifier='http://example.org/g') + badg = Graph(identifier='http://example.org/badness') + with BatchAddGraph(g) as cut: + cut.add((URIRef('a'), URIRef('b'), URIRef('c'), badg)) + self.assertEqual(0, len(g)) + + def test_add_quad_for_non_conjunctive_pass_on_context_matches(self): + g = Graph() + with BatchAddGraph(g) as cut: + cut.add((URIRef('a'), URIRef('b'), URIRef('c'), g)) + self.assertEqual(1, len(g)) + + def test_no_addN_on_exception(self): + ''' + Even if we've added triples so far, it may be that attempting to add the last + batch is the cause of our exception, so we don't want to attempt again + ''' + g = Graph() + trips = [(URIRef('a'), URIRef('b%d' % i), URIRef('c%d' % i)) + for i in range(12)] + + try: + with BatchAddGraph(g, batch_size=10) as cut: + for i, trip in enumerate(trips): + cut.add(trip) + if i == 11: + raise Exception('myexc') + except Exception as e: + if str(e) != 'myexc': + pass + self.assertEqual(10, len(g)) + + def test_addN_batching_addN(self): + class MockGraph(object): + def __init__(self): + self.counts = [] + + def addN(self, quads): + self.counts.append(sum(1 for _ in quads)) + + g = MockGraph() + quads = [(URIRef('a'), URIRef('b%d' % i), URIRef('c%d' % i), g) + for i in range(12)] + + with BatchAddGraph(g, batch_size=10, batch_addn=True) as cut: + cut.addN(quads) + self.assertEqual(g.counts, [10, 2])

[ { "components": [ { "doc": "Wrapper around graph that turns calls to :meth:`add` (and optionally, :meth:`addN`)\ninto calls to :meth:`~rdflib.graph.Graph.addN`.\n\n:Parameters:\n\n - `graph`: The graph to wrap\n - `batch_size`: The maximum number of triples to buffer before passing to\n `grap...

[ "test/test_batch_add.py::TestBatchAddGraph::test_addN_batching_addN", "test/test_batch_add.py::TestBatchAddGraph::test_add_more_than_batch_size", "test/test_batch_add.py::TestBatchAddGraph::test_add_quad_for_non_conjunctive_empty", "test/test_batch_add.py::TestBatchAddGraph::test_add_quad_for_non_conjunctive_...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Adding a wrapper for batching add() calls to a Graph - Should address RDFLib/rdflib#357 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in rdflib/graph.py] (definition of BatchAddGraph:) class BatchAddGraph(object): """Wrapper around graph that turns calls to :meth:`add` (and optionally, :meth:`addN`) into calls to :meth:`~rdflib.graph.Graph.addN`. :Parameters: - `graph`: The graph to wrap - `batch_size`: The maximum number of triples to buffer before passing to `graph`'s `addN` - `batch_addn`: If True, then even calls to `addN` will be batched according to `batch_size` :ivar graph: The wrapped graph :ivar count: The number of triples buffered since initaialization or the last call to :meth:`reset` :ivar batch: The current buffer of triples""" (definition of BatchAddGraph.__init__:) def __init__(self, graph, batch_size=1000, batch_addn=False): (definition of BatchAddGraph.reset:) def reset(self): """Manually clear the buffered triples and reset the count to zero""" (definition of BatchAddGraph.add:) def add(self, triple_or_quad): """Add a triple to the buffer :param triple: The triple to add""" (definition of BatchAddGraph.addN:) def addN(self, quads): (definition of BatchAddGraph.__enter__:) def __enter__(self): (definition of BatchAddGraph.__exit__:) def __exit__(self, *exc): [end of new definitions in rdflib/graph.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

0c11debb5178157baeac27b735e49a757916d2a6

matplotlib__matplotlib-15127

15,127

matplotlib/matplotlib

3.1

5c486d79fdc9d207d32abcdc76f0cb1b74ffaf67

2019-08-26T12:58:27Z

diff --git a/doc/api/next_api_changes/behavior/15127-TAC.rst b/doc/api/next_api_changes/behavior/15127-TAC.rst new file mode 100644 index 000000000000..fd68c0150551 --- /dev/null +++ b/doc/api/next_api_changes/behavior/15127-TAC.rst @@ -0,0 +1,8 @@ +Raise or warn on registering a colormap twice +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +When using `matplotlib.cm.register_cmap` to register a user provided +or third-party colormap it will now raise a `ValueError` if trying to +over-write one of the built in colormaps and warn if trying to over +write a user registered colormap. This may raise for user-registered +colormaps in the future. diff --git a/doc/users/next_whats_new/2019-08_tac.rst b/doc/users/next_whats_new/2019-08_tac.rst new file mode 100644 index 000000000000..3e7e3648b421 --- /dev/null +++ b/doc/users/next_whats_new/2019-08_tac.rst @@ -0,0 +1,6 @@ + +Add ``cm.unregister_cmap`` function +----------------------------------- + +`.cm.unregister_cmap` allows users to remove a colormap that they +have previously registered. diff --git a/lib/matplotlib/cm.py b/lib/matplotlib/cm.py index b8a67550bff3..d4a8b1df5cb2 100644 --- a/lib/matplotlib/cm.py +++ b/lib/matplotlib/cm.py @@ -24,6 +24,7 @@ from matplotlib import _api, colors, cbook from matplotlib._cm import datad from matplotlib._cm_listed import cmaps as cmaps_listed +from matplotlib.cbook import _warn_external LUTSIZE = mpl.rcParams['image.lut'] @@ -95,30 +96,38 @@ def _warn_deprecated(self): locals().update(_cmap_registry) # This is no longer considered public API cmap_d = _DeprecatedCmapDictWrapper(_cmap_registry) - +__builtin_cmaps = tuple(_cmap_registry) # Continue with definitions ... -def register_cmap(name=None, cmap=None, data=None, lut=None): +def register_cmap(name=None, cmap=None, *, override_builtin=False): """ Add a colormap to the set recognized by :func:`get_cmap`. - It can be used in two ways:: + Register a new colormap to be accessed by name :: + + LinearSegmentedColormap('swirly', data, lut) + register_cmap(cmap=swirly_cmap) - register_cmap(name='swirly', cmap=swirly_cmap) + Parameters + ---------- + name : str, optional + The name that can be used in :func:`get_cmap` or :rc:`image.cmap` - register_cmap(name='choppy', data=choppydata, lut=128) + If absent, the name will be the :attr:`~matplotlib.colors.Colormap.name` + attribute of the *cmap*. - In the first case, *cmap* must be a :class:`matplotlib.colors.Colormap` - instance. The *name* is optional; if absent, the name will - be the :attr:`~matplotlib.colors.Colormap.name` attribute of the *cmap*. + cmap : matplotlib.colors.Colormap + Despite being the second argument and having a default value, this + is a required argument. - The second case is deprecated. Here, the three arguments are passed to - the :class:`~matplotlib.colors.LinearSegmentedColormap` initializer, - and the resulting colormap is registered. Instead of this implicit - colormap creation, create a `.LinearSegmentedColormap` and use the first - case: ``register_cmap(cmap=LinearSegmentedColormap(name, data, lut))``. + override_builtin : bool + + Allow built-in colormaps to be overridden by a user-supplied + colormap. + + Please do not use this unless you are sure you need it. Notes ----- @@ -126,6 +135,7 @@ def register_cmap(name=None, cmap=None, data=None, lut=None): which can currently be modified and inadvertantly change the global colormap state. This behavior is deprecated and in Matplotlib 3.5 the registered colormap will be immutable. + """ cbook._check_isinstance((str, None), name=name) if name is None: @@ -134,23 +144,21 @@ def register_cmap(name=None, cmap=None, data=None, lut=None): except AttributeError as err: raise ValueError("Arguments must include a name or a " "Colormap") from err - if isinstance(cmap, colors.Colormap): - cmap._global = True - _cmap_registry[name] = cmap - return - if lut is not None or data is not None: - cbook.warn_deprecated( - "3.3", - message="Passing raw data via parameters data and lut to " - "register_cmap() is deprecated since %(since)s and will " - "become an error %(removal)s. Instead use: register_cmap(" - "cmap=LinearSegmentedColormap(name, data, lut))") - # For the remainder, let exceptions propagate. - if lut is None: - lut = mpl.rcParams['image.lut'] - cmap = colors.LinearSegmentedColormap(name, data, lut) + if name in _cmap_registry: + if not override_builtin and name in __builtin_cmaps: + msg = f"Trying to re-register the builtin cmap {name!r}." + raise ValueError(msg) + else: + msg = f"Trying to register the cmap {name!r} which already exists." + _warn_external(msg) + + if not isinstance(cmap, colors.Colormap): + raise ValueError("You must pass a Colormap instance. " + f"You passed {cmap} a {type(cmap)} object.") + cmap._global = True _cmap_registry[name] = cmap + return def get_cmap(name=None, lut=None): @@ -187,6 +195,47 @@ def get_cmap(name=None, lut=None): return _cmap_registry[name]._resample(lut) +def unregister_cmap(name): + """ + Remove a colormap recognized by :func:`get_cmap`. + + You may not remove built-in colormaps. + + If the named colormap is not registered, returns with no error, raises + if you try to de-register a default colormap. + + .. warning :: + + Colormap names are currently a shared namespace that may be used + by multiple packages. Use `unregister_cmap` only if you know you + have registered that name before. In particular, do not + unregister just in case to clean the name before registering a + new colormap. + + Parameters + ---------- + name : str + The name of the colormap to be un-registered + + Returns + ------- + ColorMap or None + If the colormap was registered, return it if not return `None` + + Raises + ------ + ValueError + If you try to de-register a default built-in colormap. + + """ + if name not in _cmap_registry: + return + if name in __builtin_cmaps: + raise ValueError(f"cannot unregister {name!r} which is a builtin " + "colormap.") + return _cmap_registry.pop(name) + + class ScalarMappable: """ A mixin class to map scalar data to RGBA. diff --git a/lib/matplotlib/colors.py b/lib/matplotlib/colors.py index 3e8226b0ce25..9500e5234ff1 100644 --- a/lib/matplotlib/colors.py +++ b/lib/matplotlib/colors.py @@ -652,7 +652,7 @@ def get_bad(self): """Get the color for masked values.""" if not self._isinit: self._init() - return self._lut[self._i_bad] + return np.array(self._lut[self._i_bad]) def set_bad(self, color='k', alpha=None): """Set the color for masked values.""" @@ -665,7 +665,7 @@ def get_under(self): """Get the color for low out-of-range values.""" if not self._isinit: self._init() - return self._lut[self._i_under] + return np.array(self._lut[self._i_under]) def set_under(self, color='k', alpha=None): """Set the color for low out-of-range values.""" @@ -678,7 +678,7 @@ def get_over(self): """Get the color for high out-of-range values.""" if not self._isinit: self._init() - return self._lut[self._i_over] + return np.array(self._lut[self._i_over]) def set_over(self, color='k', alpha=None): """Set the color for high out-of-range values."""

diff --git a/lib/matplotlib/tests/test_colors.py b/lib/matplotlib/tests/test_colors.py index d180fb28afa5..8a1a96b47389 100644 --- a/lib/matplotlib/tests/test_colors.py +++ b/lib/matplotlib/tests/test_colors.py @@ -64,14 +64,44 @@ def test_resample(): def test_register_cmap(): - new_cm = copy.copy(plt.cm.viridis) - cm.register_cmap('viridis2', new_cm) - assert plt.get_cmap('viridis2') == new_cm + new_cm = copy.copy(cm.get_cmap("viridis")) + target = "viridis2" + cm.register_cmap(target, new_cm) + assert plt.get_cmap(target) == new_cm with pytest.raises(ValueError, - match='Arguments must include a name or a Colormap'): + match="Arguments must include a name or a Colormap"): cm.register_cmap() + with pytest.warns(UserWarning): + cm.register_cmap(target, new_cm) + + cm.unregister_cmap(target) + with pytest.raises(ValueError, + match=f'{target!r} is not a valid value for name;'): + cm.get_cmap(target) + # test that second time is error free + cm.unregister_cmap(target) + + with pytest.raises(ValueError, match="You must pass a Colormap instance."): + cm.register_cmap('nome', cmap='not a cmap') + + +def test_double_register_builtin_cmap(): + name = "viridis" + match = f"Trying to re-register the builtin cmap {name!r}." + with pytest.raises(ValueError, match=match): + cm.register_cmap(name, cm.get_cmap(name)) + with pytest.warns(UserWarning): + cm.register_cmap(name, cm.get_cmap(name), override_builtin=True) + + +def test_unregister_builtin_cmap(): + name = "viridis" + match = f'cannot unregister {name!r} which is a builtin colormap.' + with pytest.raises(ValueError, match=match): + cm.unregister_cmap(name) + def test_colormap_global_set_warn(): new_cm = plt.get_cmap('viridis') @@ -94,7 +124,8 @@ def test_colormap_global_set_warn(): new_cm.set_under('k') # Re-register the original - plt.register_cmap(cmap=orig_cmap) + with pytest.warns(UserWarning): + plt.register_cmap(cmap=orig_cmap, override_builtin=True) def test_colormap_dict_deprecate(): @@ -1187,6 +1218,16 @@ def test_get_under_over_bad(): assert_array_equal(cmap.get_bad(), cmap(np.nan)) +@pytest.mark.parametrize('kind', ('over', 'under', 'bad')) +def test_non_mutable_get_values(kind): + cmap = copy.copy(plt.get_cmap('viridis')) + init_value = getattr(cmap, f'get_{kind}')() + getattr(cmap, f'set_{kind}')('k') + black_value = getattr(cmap, f'get_{kind}')() + assert np.all(black_value == [0, 0, 0, 1]) + assert not np.all(init_value == black_value) + + def test_colormap_alpha_array(): cmap = plt.get_cmap('viridis') vals = [-1, 0.5, 2] # under, valid, over

diff --git a/doc/api/next_api_changes/behavior/15127-TAC.rst b/doc/api/next_api_changes/behavior/15127-TAC.rst new file mode 100644 index 000000000000..fd68c0150551 --- /dev/null +++ b/doc/api/next_api_changes/behavior/15127-TAC.rst @@ -0,0 +1,8 @@ +Raise or warn on registering a colormap twice +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +When using `matplotlib.cm.register_cmap` to register a user provided +or third-party colormap it will now raise a `ValueError` if trying to +over-write one of the built in colormaps and warn if trying to over +write a user registered colormap. This may raise for user-registered +colormaps in the future. diff --git a/doc/users/next_whats_new/2019-08_tac.rst b/doc/users/next_whats_new/2019-08_tac.rst new file mode 100644 index 000000000000..3e7e3648b421 --- /dev/null +++ b/doc/users/next_whats_new/2019-08_tac.rst @@ -0,0 +1,6 @@ + +Add ``cm.unregister_cmap`` function +----------------------------------- + +`.cm.unregister_cmap` allows users to remove a colormap that they +have previously registered.

[ { "components": [ { "doc": "Remove a colormap recognized by :func:`get_cmap`.\n\nYou may not remove built-in colormaps.\n\nIf the named colormap is not registered, returns with no error, raises\nif you try to de-register a default colormap.\n\n.. warning ::\n\n Colormap names are currently a shar...

[ "lib/matplotlib/tests/test_colors.py::test_register_cmap", "lib/matplotlib/tests/test_colors.py::test_double_register_builtin_cmap", "lib/matplotlib/tests/test_colors.py::test_unregister_builtin_cmap", "lib/matplotlib/tests/test_colors.py::test_colormap_global_set_warn", "lib/matplotlib/tests/test_colors.py...

[ "lib/matplotlib/tests/test_colors.py::test_create_lookup_table[5-result0]", "lib/matplotlib/tests/test_colors.py::test_create_lookup_table[2-result1]", "lib/matplotlib/tests/test_colors.py::test_create_lookup_table[1-result2]", "lib/matplotlib/tests/test_colors.py::test_resample", "lib/matplotlib/tests/test...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> ENH/API: improvements to register_cmap - protect re-defining built in color maps - warn on re-defining user-defined color maps - add de-register function - [x] Has Pytest style unit tests - [x] Code is [Flake 8](http://flake8.pycqa.org/en/latest/) compliant - [x] New features are documented, with examples if plot related - [x] Documentation is sphinx and numpydoc compliant - [x] Added an entry to doc/users/next_whats_new/ if major new feature (follow instructions in README.rst there) - [x] Documented in doc/api/api_changes.rst if API changed in a backward-incompatible way  ---------- The general idea seems that matplotlib encourages a lot of third party packages to spawn in the wild, each with one or more colormaps, and each registering their colormaps via the `cm` module. Because there is easily some overlap between those to be expected (package 1 has "rocket", "moon" and "silveraqua", package 2 has "rocket" and "desertnight", user needs to import both because they need "silveraqua" and "desertnight"), there should be a solution that allows both packages to be imported without error. Even the warning might be annoying, in case "rocket" from package 1 and "rocket" from package 2 are in fact identical. Perhaps we should just not use string names and instead use normal qualified python names (`mypackage.mycmap`)... --- edit to clarify: If you're going to need an import to trigger the registration, you already have the module imported, so it's just as good to access an attribute from that module; because module names are unique (in a flat namespace), this handles the problem of name collision for us. ... and, per @jklymak's comment below, now you don't even need to have a registration API. As a meta comment, I mess w colormaps all the time and don’t ever bother registering them. But maybe that’s because I’ve never bothered to set up my own startup package. Agree w @ImportanceOfBeingErnest that being able to override colormap names should be allowed. If I want to replace jet with turbo and call it jet, why not? Overall, what is the end-user interface for colormaps? We really could use documentation on this. Are we all supposed to have our own pip installable packages myplottingsettings ? This feeds into the python matplotlibrc question In order to not be misunderstood here: I did not say one should allow for matplotlib's colormaps to be overridden. In fact a protection layer like the one proposed in this PR makes perfect sense. My comment above was about not protecting additional/external colormaps; or at least find a solution for the case that several packages try to register the same colormap under the same name. Flake8: > ./lib/matplotlib/cm.py:30:1: E302 expected 2 blank lines, found 1 Moved to new doc scheme and took @dstansby 's completion of the sentence. Where do we stand on this in light of #16943 and other discussions in the meeting? This is orthogonal to #16943. While #16943 addresses modification of the default colormap objects, this here addresses replacing default colormap objects. This has three approvals - just needs a rebase? I guess all the tests need to pass as well... </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in lib/matplotlib/cm.py] (definition of unregister_cmap:) def unregister_cmap(name): """Remove a colormap recognized by :func:`get_cmap`. You may not remove built-in colormaps. If the named colormap is not registered, returns with no error, raises if you try to de-register a default colormap. .. warning :: Colormap names are currently a shared namespace that may be used by multiple packages. Use `unregister_cmap` only if you know you have registered that name before. In particular, do not unregister just in case to clean the name before registering a new colormap. Parameters ---------- name : str The name of the colormap to be un-registered Returns ------- ColorMap or None If the colormap was registered, return it if not return `None` Raises ------ ValueError If you try to de-register a default built-in colormap.""" [end of new definitions in lib/matplotlib/cm.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c9be5a6985cc919703959902e9a8d795cfde03ad

joke2k__faker-989

989

joke2k/faker

null

46450c265271029b6cf0c5fa3c5c2e0d4508ca27

2019-08-22T18:19:01Z

diff --git a/faker/providers/date_time/__init__.py b/faker/providers/date_time/__init__.py index 39dab8380f..529db17573 100644 --- a/faker/providers/date_time/__init__.py +++ b/faker/providers/date_time/__init__.py @@ -4,7 +4,7 @@ from datetime import MAXYEAR, timedelta from dateutil import relativedelta -from dateutil.tz import tzlocal, tzutc +from dateutil.tz import gettz, tzlocal, tzutc from faker.utils.datetime_safe import date, datetime, real_date, real_datetime @@ -1962,6 +1962,17 @@ def timezone(self): return self.generator.random.choice( self.random_element(self.countries)['timezones']) + def pytimezone(self, *args, **kwargs): + """ + Generate a random timezone (see `faker.timezone` for any args) + and return as a python object usable as a `tzinfo` to `datetime` + or other fakers. + + :example faker.pytimezone() + :return dateutil.tz.tz.tzfile + """ + return gettz(self.timezone(*args, **kwargs)) + def date_of_birth(self, tzinfo=None, minimum_age=0, maximum_age=115): """ Generate a random date of birth represented as a Date object,

diff --git a/tests/providers/test_date_time.py b/tests/providers/test_date_time.py index 30e9cf0949..ad951a5f13 100644 --- a/tests/providers/test_date_time.py +++ b/tests/providers/test_date_time.py @@ -138,6 +138,16 @@ def test_timezone_conversion(self): today_back = datetime.fromtimestamp(timestamp, utc).date() assert today == today_back + def test_pytimezone(self): + import dateutil + pytz = self.fake.pytimezone() + assert isinstance(pytz, dateutil.tz.tz.tzfile) + + def test_pytimezone_usable(self): + pytz = self.fake.pytimezone() + date = datetime(2000, 1, 1, tzinfo=pytz) + assert date.tzinfo == pytz + def test_datetime_safe(self): from faker.utils import datetime_safe # test using example provided in module

[ { "components": [ { "doc": "Generate a random timezone (see `faker.timezone` for any args)\nand return as a python object usable as a `tzinfo` to `datetime`\nor other fakers.\n\n:example faker.pytimezone()\n:return dateutil.tz.tz.tzfile", "lines": [ 1965, 1974 ]...

[ "tests/providers/test_date_time.py::TestDateTime::test_pytimezone", "tests/providers/test_date_time.py::TestDateTime::test_pytimezone_usable" ]

[ "tests/providers/test_date_time.py::TestKoKR::test_day", "tests/providers/test_date_time.py::TestKoKR::test_month", "tests/providers/test_date_time.py::TestDateTime::test_date_between", "tests/providers/test_date_time.py::TestDateTime::test_date_between_dates", "tests/providers/test_date_time.py::TestDateTi...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add pytimezone for tzinfo objects ### What does this changes Adds a python object faker around the existing `timezone` name faker. ### What was wrong It was a bit of a pain (multiple steps) to fake dates with fake tzinfo. ### How this fixes it It removes one of the steps! Fixes #988 NB: I thought about also doing something like `tzinfo=True` (or a new kwarg) as an argument to the other datetime methods, that makes them use `pytimezone` to generate a tzinfo instead of expecting one. That's more work though, so I thought I'd leave it without agreement on the principle. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/date_time/__init__.py] (definition of Provider.pytimezone:) def pytimezone(self, *args, **kwargs): """Generate a random timezone (see `faker.timezone` for any args) and return as a python object usable as a `tzinfo` to `datetime` or other fakers. :example faker.pytimezone() :return dateutil.tz.tz.tzfile""" [end of new definitions in faker/providers/date_time/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> suggestion: pytimezone In addition to the currently available [timezone](), it would be very useful* to have a similar python object faker, something like: ```python import pytz class TheExistingPythonProvider: def pytimezone(self, **kwargs): return pytz.timezone(self.generator.timezone(**kwargs)) ``` For an example use-case, see: \* FactoryBoy/factory_boy#643 ---------- I'm +1 on add a timezone provider. I just wonder if it should go into the `date_time` provider than the `python` one. Either way, feel free to submit a PR and I'll review it :) Oh, true, since date_time provider does already have python `datetime` objects. 👍 Will do. -------------------- </issues>

6edfdbf6ae90b0153309e3bf066aa3b2d16494a7

sympy__sympy-17472

17,472

sympy/sympy

1.5

261c6c3f33955aaa3e13b8c9607dd80bf4021268

2019-08-21T10:18:36Z

diff --git a/sympy/functions/elementary/complexes.py b/sympy/functions/elementary/complexes.py index abfeffa76d1b..b91aa60d7ea5 100644 --- a/sympy/functions/elementary/complexes.py +++ b/sympy/functions/elementary/complexes.py @@ -628,6 +628,9 @@ def _eval_rewrite_as_Piecewise(self, arg, **kwargs): def _eval_rewrite_as_sign(self, arg, **kwargs): return arg/sign(arg) + def _eval_rewrite_as_conjugate(self, arg, **kwargs): + return (arg*conjugate(arg))**(S.Half) + class arg(Function): """

diff --git a/sympy/functions/elementary/tests/test_complexes.py b/sympy/functions/elementary/tests/test_complexes.py index 294a01910a66..00876965708f 100644 --- a/sympy/functions/elementary/tests/test_complexes.py +++ b/sympy/functions/elementary/tests/test_complexes.py @@ -478,6 +478,14 @@ def test_Abs_rewrite(): assert abs(i).rewrite(Piecewise) == Piecewise((I*i, I*i >= 0), (-I*i, True)) + assert Abs(y).rewrite(conjugate) == sqrt(y*conjugate(y)) + assert Abs(i).rewrite(conjugate) == sqrt(-i**2) # == -I*i + + y = Symbol('y', extended_real=True) + assert (Abs(exp(-I*x)-exp(-I*y))**2).rewrite(conjugate) == \ + -exp(I*x)*exp(-I*y) + 2 - exp(-I*x)*exp(I*y) + + def test_Abs_real(): # test some properties of abs that only apply # to real numbers

[ { "components": [ { "doc": "", "lines": [ 631, 632 ], "name": "Abs._eval_rewrite_as_conjugate", "signature": "def _eval_rewrite_as_conjugate(self, arg, **kwargs):", "type": "function" } ], "file": "sympy/functions/elementary...

[ "test_Abs_rewrite" ]

[ "test_re", "test_im", "test_sign", "test_as_real_imag", "test_Abs", "test_Abs_real", "test_Abs_properties", "test_abs", "test_arg", "test_arg_rewrite", "test_adjoint", "test_conjugate", "test_conjugate_transpose", "test_transpose", "test_polarify", "test_unpolarify", "test_issue_4035...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Rewrite Abs as conjugate  #### References to other Issues or PRs  #### Brief description of what is fixed or changed Abs can now be rewritten as conjugate. Motivating example is: ``` (Abs(exp(-I*x)-exp(-I*y))**2).rewrite(conjugate) ``` which gives ``` -exp(I*x)*exp(-I*y) + 2 - exp(-I*x)*exp(I*y) ``` (with x and y real). Useful for signal processing applications if nothing else. #### Other comments #### Release Notes   * functions * `Abs` can be rewritten as `conjugate`.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/functions/elementary/complexes.py] (definition of Abs._eval_rewrite_as_conjugate:) def _eval_rewrite_as_conjugate(self, arg, **kwargs): [end of new definitions in sympy/functions/elementary/complexes.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-17429

17,429

sympy/sympy

1.5

40da07b3a8ca3b315aaf25ec4ac21dfe4364a097

2019-08-15T22:02:13Z

diff --git a/sympy/functions/elementary/exponential.py b/sympy/functions/elementary/exponential.py index 5a5ee285715b..4cd84f026f7f 100644 --- a/sympy/functions/elementary/exponential.py +++ b/sympy/functions/elementary/exponential.py @@ -491,11 +491,11 @@ def _eval_rewrite_as_Pow(self, arg, **kwargs): return Pow(logs[0].args[0], arg.coeff(logs[0])) -def _match_real_imag(expr): +def match_real_imag(expr): """ Try to match expr with a + b*I for real a and b. - ``_match_real_imag`` returns a tuple containing the real and imaginary + ``match_real_imag`` returns a tuple containing the real and imaginary parts of expr or (None, None) if direct matching is not possible. Contrary to ``re()``, ``im()``, ``as_real_imag()``, this helper won't force things by returning expressions themselves containing ``re()`` or ``im()`` and it @@ -607,7 +607,7 @@ def eval(cls, arg, base=None): if isinstance(arg, exp) and arg.args[0].is_extended_real: return arg.args[0] elif isinstance(arg, exp) and arg.args[0].is_number: - r_, i_ = _match_real_imag(arg.args[0]) + r_, i_ = match_real_imag(arg.args[0]) if i_ and i_.is_comparable: i_ %= 2*S.Pi if i_ > S.Pi: diff --git a/sympy/functions/elementary/hyperbolic.py b/sympy/functions/elementary/hyperbolic.py index dde790eb5562..f7b18da97b7d 100644 --- a/sympy/functions/elementary/hyperbolic.py +++ b/sympy/functions/elementary/hyperbolic.py @@ -1,11 +1,12 @@ from __future__ import print_function, division -from sympy.core import S, sympify, cacheit +from sympy.core import S, sympify, cacheit, pi, I from sympy.core.add import Add from sympy.core.function import Function, ArgumentIndexError, _coeff_isneg from sympy.functions.combinatorial.factorials import factorial, RisingFactorial -from sympy.functions.elementary.exponential import exp, log +from sympy.functions.elementary.exponential import exp, log, match_real_imag from sympy.functions.elementary.miscellaneous import sqrt +from sympy.functions.elementary.integers import floor def _rewrite_hyperbolics_as_exp(expr): @@ -926,6 +927,20 @@ def eval(cls, arg): if _coeff_isneg(arg): return -cls(-arg) + if isinstance(arg, sinh) and arg.args[0].is_number: + z = arg.args[0] + if z.is_real: + return z + r, i = match_real_imag(z) + if r is not None and i is not None: + f = floor((i + pi/2)/pi) + m = z - I*pi*f + even = f.is_even + if even is True: + return m + elif even is False: + return -m + @staticmethod @cacheit def taylor_term(n, x, *previous_terms): @@ -1033,6 +1048,28 @@ def eval(cls, arg): if arg == -S.ImaginaryUnit*S.Infinity: return S.Infinity - S.ImaginaryUnit*S.Pi/2 + if isinstance(arg, cosh) and arg.args[0].is_number: + z = arg.args[0] + if z.is_real: + from sympy.functions.elementary.complexes import Abs + return Abs(z) + r, i = match_real_imag(z) + if r is not None and i is not None: + f = floor(i/pi) + m = z - I*pi*f + even = f.is_even + if even is True: + if r.is_nonnegative: + return m + elif r.is_negative: + return -m + elif even is False: + m -= I*pi + if r.is_nonpositive: + return -m + elif r.is_positive: + return m + @staticmethod @cacheit def taylor_term(n, x, *previous_terms): @@ -1121,6 +1158,20 @@ def eval(cls, arg): if _coeff_isneg(arg): return -cls(-arg) + if isinstance(arg, tanh) and arg.args[0].is_number: + z = arg.args[0] + if z.is_real: + return z + r, i = match_real_imag(z) + if r is not None and i is not None: + f = floor(2*i/pi) + even = f.is_even + m = z - I*f*pi/2 + if even is True: + return m + elif even is False: + return m - I*pi/2 + @staticmethod @cacheit def taylor_term(n, x, *previous_terms):

diff --git a/sympy/core/tests/test_evalf.py b/sympy/core/tests/test_evalf.py index 52aa0a56eb35..63a034768552 100644 --- a/sympy/core/tests/test_evalf.py +++ b/sympy/core/tests/test_evalf.py @@ -1,7 +1,7 @@ from sympy import (Abs, Add, atan, ceiling, cos, E, Eq, exp, factor, factorial, fibonacci, floor, Function, GoldenRatio, I, Integral, integrate, log, Mul, N, oo, pi, Pow, product, Product, - Rational, S, Sum, simplify, sin, sqrt, sstr, sympify, Symbol, Max, nfloat) + Rational, S, Sum, simplify, sin, sqrt, sstr, sympify, Symbol, Max, nfloat, cosh, acosh, acos) from sympy.core.numbers import comp from sympy.core.evalf import (complex_accuracy, PrecisionExhausted, scaled_zero, get_integer_part, as_mpmath, evalf) @@ -567,3 +567,7 @@ def test_issue_13425(): assert N('2**.5', 30) == N('sqrt(2)', 30) assert N('x - x', 30) == 0 assert abs((N('pi*.1', 22)*10 - pi).n()) < 1e-22 + + +def test_issue_17421(): + assert N(acos(-I + acosh(cosh(cosh(1) + I)))) == 1.0*I diff --git a/sympy/functions/elementary/tests/test_exponential.py b/sympy/functions/elementary/tests/test_exponential.py index c7794d845e31..9a18a0988a2f 100644 --- a/sympy/functions/elementary/tests/test_exponential.py +++ b/sympy/functions/elementary/tests/test_exponential.py @@ -3,7 +3,7 @@ LambertW, sqrt, Rational, expand_log, S, sign, conjugate, refine, sin, cos, sinh, cosh, tanh, exp_polar, re, Function, simplify, AccumBounds, MatrixSymbol, Pow, gcd, Sum, Product) -from sympy.functions.elementary.exponential import _match_real_imag +from sympy.functions.elementary.exponential import match_real_imag from sympy.abc import x, y, z from sympy.core.expr import unchanged from sympy.core.function import ArgumentIndexError @@ -221,16 +221,16 @@ def test_log_values(): def test_match_real_imag(): x, y = symbols('x,y', real=True) i = Symbol('i', imaginary=True) - assert _match_real_imag(S.One) == (1, 0) - assert _match_real_imag(I) == (0, 1) - assert _match_real_imag(3 - 5*I) == (3, -5) - assert _match_real_imag(-sqrt(3) + S.Half*I) == (-sqrt(3), S.Half) - assert _match_real_imag(x + y*I) == (x, y) - assert _match_real_imag(x*I + y*I) == (0, x + y) - assert _match_real_imag((x + y)*I) == (0, x + y) - assert _match_real_imag(-S(2)/3*i*I) == (None, None) - assert _match_real_imag(1 - 2*i) == (None, None) - assert _match_real_imag(sqrt(2)*(3 - 5*I)) == (None, None) + assert match_real_imag(S.One) == (1, 0) + assert match_real_imag(I) == (0, 1) + assert match_real_imag(3 - 5*I) == (3, -5) + assert match_real_imag(-sqrt(3) + S.Half*I) == (-sqrt(3), S.Half) + assert match_real_imag(x + y*I) == (x, y) + assert match_real_imag(x*I + y*I) == (0, x + y) + assert match_real_imag((x + y)*I) == (0, x + y) + assert match_real_imag(-S(2)/3*i*I) == (None, None) + assert match_real_imag(1 - 2*i) == (None, None) + assert match_real_imag(sqrt(2)*(3 - 5*I)) == (None, None) def test_log_exact(): diff --git a/sympy/functions/elementary/tests/test_hyperbolic.py b/sympy/functions/elementary/tests/test_hyperbolic.py index dd21df540d65..237533224ea2 100644 --- a/sympy/functions/elementary/tests/test_hyperbolic.py +++ b/sympy/functions/elementary/tests/test_hyperbolic.py @@ -1,7 +1,7 @@ from sympy import (symbols, Symbol, sinh, nan, oo, zoo, pi, asinh, acosh, log, sqrt, coth, I, cot, E, tanh, tan, cosh, cos, S, sin, Rational, atanh, acoth, Integer, O, exp, sech, sec, csch, asech, acsch, acos, asin, expand_mul, - AccumBounds, im, re) + AccumBounds, im, re, Abs) from sympy.core.expr import unchanged from sympy.core.function import ArgumentIndexError @@ -508,6 +508,20 @@ def test_asinh(): # Symmetry assert asinh(-S.Half) == -asinh(S.Half) + # inverse composition + assert unchanged(asinh, sinh(Symbol('v1'))) + + assert asinh(sinh(0, evaluate=False)) == 0 + assert asinh(sinh(-3, evaluate=False)) == -3 + assert asinh(sinh(2, evaluate=False)) == 2 + assert asinh(sinh(I, evaluate=False)) == I + assert asinh(sinh(-I, evaluate=False)) == -I + assert asinh(sinh(5*I, evaluate=False)) == -2*I*pi + 5*I + assert asinh(sinh(15 + 11*I)) == 15 - 4*I*pi + 11*I + assert asinh(sinh(-73 + 97*I)) == 73 - 97*I + 31*I*pi + assert asinh(sinh(-7 - 23*I)) == 7 - 7*I*pi + 23*I + assert asinh(sinh(13 - 3*I)) == -13 - I*pi + 3*I + def test_asinh_rewrite(): x = Symbol('x') @@ -570,6 +584,22 @@ def test_acosh(): assert str(acosh(5*I).n(6)) == '2.31244 + 1.5708*I' assert str(acosh(-5*I).n(6)) == '2.31244 - 1.5708*I' + # inverse composition + assert unchanged(acosh, Symbol('v1')) + + assert acosh(cosh(-3, evaluate=False)) == 3 + assert acosh(cosh(3, evaluate=False)) == 3 + assert acosh(cosh(0, evaluate=False)) == 0 + assert acosh(cosh(I, evaluate=False)) == I + assert acosh(cosh(-I, evaluate=False)) == I + assert acosh(cosh(7*I, evaluate=False)) == -2*I*pi + 7*I + assert acosh(cosh(1 + I)) == 1 + I + assert acosh(cosh(3 - 3*I)) == 3 - 3*I + assert acosh(cosh(-3 + 2*I)) == 3 - 2*I + assert acosh(cosh(-5 - 17*I)) == 5 - 6*I*pi + 17*I + assert acosh(cosh(-21 + 11*I)) == 21 - 11*I + 4*I*pi + assert acosh(cosh(cosh(1) + I)) == cosh(1) + I + def test_acosh_rewrite(): x = Symbol('x') @@ -780,6 +810,24 @@ def test_atanh(): # Symmetry assert atanh(-S.Half) == -atanh(S.Half) + # inverse composition + assert unchanged(atanh, tanh(Symbol('v1'))) + + assert atanh(tanh(-5, evaluate=False)) == -5 + assert atanh(tanh(0, evaluate=False)) == 0 + assert atanh(tanh(7, evaluate=False)) == 7 + assert atanh(tanh(I, evaluate=False)) == I + assert atanh(tanh(-I, evaluate=False)) == -I + assert atanh(tanh(-11*I, evaluate=False)) == -11*I + 4*I*pi + assert atanh(tanh(3 + I)) == 3 + I + assert atanh(tanh(4 + 5*I)) == 4 - 2*I*pi + 5*I + assert atanh(tanh(pi/2)) == pi/2 + assert atanh(tanh(pi)) == pi + assert atanh(tanh(-3 + 7*I)) == -3 - 2*I*pi + 7*I + assert atanh(tanh(9 - 2*I/3)) == 9 - 2*I/3 + assert atanh(tanh(-32 - 123*I)) == -32 - 123*I + 39*I*pi + + def test_atanh_rewrite(): x = Symbol('x') assert atanh(x).rewrite(log) == (log(1 + x) - log(1 - x)) / 2

[ { "components": [ { "doc": "Try to match expr with a + b*I for real a and b.\n\n``match_real_imag`` returns a tuple containing the real and imaginary\nparts of expr or (None, None) if direct matching is not possible. Contrary\nto ``re()``, ``im()``, ``as_real_imag()``, this helper won't force thin...

[ "test_exp_values", "test_exp_period", "test_exp_log", "test_exp_expand", "test_exp__as_base_exp", "test_exp_infinity", "test_exp_subs", "test_exp_conjugate", "test_exp_rewrite", "test_exp_leading_term", "test_exp_taylor_term", "test_exp_MatrixSymbol", "test_exp_fdiff", "test_log_values", ...

[ "test_evalf_helpers", "test_evalf_basic", "test_cancellation", "test_evalf_powers", "test_evalf_rump", "test_evalf_complex", "test_evalf_complex_powers", "test_evalf_exponentiation", "test_evalf_complex_cancellation", "test_evalf_logs", "test_evalf_trig", "test_evalf_near_integers", "test_ev...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add automatic evaluation for compositions of inverse hyperbolic functions #### References to other Issues or PRs Closes #17421. The more difficult issue with evaluation near branch cuts is not addressed, but there is another issue that covers that (#6137). #### Brief description of what is fixed or changed Add automatic evaluation of `atanh(tanh(x)), acosh(cosh(x)), asinh(sinh(x))` for suitable `x`. #### Release Notes  * functions * atanh(tanh(x)), acosh(cosh(x)) and asinh(sinh(x)) are automatically evaluated  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/functions/elementary/exponential.py] (definition of match_real_imag:) def match_real_imag(expr): """Try to match expr with a + b*I for real a and b. ``match_real_imag`` returns a tuple containing the real and imaginary parts of expr or (None, None) if direct matching is not possible. Contrary to ``re()``, ``im()``, ``as_real_imag()``, this helper won't force things by returning expressions themselves containing ``re()`` or ``im()`` and it doesn't expand its argument either.""" [end of new definitions in sympy/functions/elementary/exponential.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Incorrect evaluation of acos(-I + acosh(cosh(cosh(1) + I))) `-I + acosh(cosh(cosh(1) + I))` should be equivalent to `cosh(1)`, and this can be confirmed: ``` >>> N(-I + acosh(cosh(cosh(1) + I))) 1.54308063481524 + 0.e-20*I >>> N(cosh(1)) 1.54308063481524 ``` Taking `acos`, the sign gets flipped: ``` >>> a = -I + acosh(cosh(cosh(1) + I)) >>> N(acos(a)) 3.60377845017333e-22 - 1.0*I >>> N(acos(cosh(1))) 1.0*I ``` Trying with explicit evaluation: ``` >>> a = -I + acosh(cosh(cosh(1) + I)) >>> N(acos(a)) 3.60377845017333e-22 - 1.0*I >>> N(a) 1.54308063481524 + 0.e-20*I >>> acos(_) 1.15320910405546e-20 - 1.0*I >>> acos(1.54308063481524 + 0.e-20*I) 0.999999999999997*I >>> acos(1.54308063481524) 0.999999999999997*I ``` ---------- Actually, I think this is more of a mpmath issue- will close unless anyone feels otherwise. What makes you think it is an issue with mpmath rather than sympy? Never mind. I guess the issue is that any positive imaginary part no matter how small is going to cause the sign to flip from `I` to `-I`. perhaps related to #6137? See this [comment](https://github.com/sympy/sympy/issues/6137#issuecomment-37004430). Maybe evalf should have some understanding of branch cuts at least so that it doesn't report excess precision near to them. Or maybe just any way to simplify `acosh(cosh(x))`? As far as I know there's nothing in `trigsimp` (or anywhere) that deals with hyperbolic inverse compositions. Something like this: ``` def acosh_simp(x): # simplify acosh(cosh(x)) if x.is_real: if x.is_nonnegative: return x elif x.is_negative: return -x else: r, i = x.as_real_imag() if r.is_number and i.is_number: n1 = floor(i / pi) if n1 % 2 == 0: m = r + I * (i - pi*n1) if r.is_nonnegative: return m else: return -m else: m = r + I * (i - pi*n1 - pi) if r.is_nonpositive: return -m else: return m ``` -------------------- </issues>

c72f122f67553e1af930bac6c35732d2a0bbb776

prometheus__client_python-453

453

prometheus/client_python

null

86018734d50bb385d75a0abf0f62c4bb0d0c24cf

2019-08-13T13:02:19Z

diff --git a/prometheus_client/registry.py b/prometheus_client/registry.py index fa2717fb..7f86a000 100644 --- a/prometheus_client/registry.py +++ b/prometheus_client/registry.py @@ -12,11 +12,13 @@ class CollectorRegistry(object): exposition formats. """ - def __init__(self, auto_describe=False): + def __init__(self, auto_describe=False, target_info=None): self._collector_to_names = {} self._names_to_collectors = {} self._auto_describe = auto_describe self._lock = Lock() + self._target_info = {} + self.set_target_info(target_info) def register(self, collector): """Add a collector to the registry.""" @@ -69,8 +71,13 @@ def _get_names(self, collector): def collect(self): """Yields metrics from the collectors in the registry.""" collectors = None + ti = None with self._lock: collectors = copy.copy(self._collector_to_names) + if self._target_info: + ti = self._target_info_metric() + if ti: + yield ti for collector in collectors: for metric in collector.collect(): yield metric @@ -87,11 +94,14 @@ def restricted_registry(self, names): Experimental.""" names = set(names) collectors = set() + metrics = [] with self._lock: + if 'target_info' in names and self._target_info: + metrics.append(self._target_info_metric()) + names.remove('target_info') for name in names: if name in self._names_to_collectors: collectors.add(self._names_to_collectors[name]) - metrics = [] for collector in collectors: for metric in collector.collect(): samples = [s for s in metric.samples if s[0] in names] @@ -106,6 +116,25 @@ def collect(self): return RestrictedRegistry() + def set_target_info(self, labels): + with self._lock: + if labels: + if not self._target_info and 'target_info' in self._names_to_collectors: + raise ValueError('CollectorRegistry already contains a target_info metric') + self._names_to_collectors['target_info'] = None + elif self._target_info: + self._names_to_collectors.pop('target_info', None) + self._target_info = labels + + def get_target_info(self): + with self._lock: + return self._target_info + + def _target_info_metric(self): + m = Metric('target', 'Target metadata', 'info') + m.add_sample('target_info', self._target_info, 1) + return m + def get_sample_value(self, name, labels=None): """Returns the sample value, or None if not found.

diff --git a/tests/test_core.py b/tests/test_core.py index 9ad947cd..dac5c044 100644 --- a/tests/test_core.py +++ b/tests/test_core.py @@ -664,6 +664,9 @@ def test_duplicate_metrics_raises(self): # The name of the histogram itself isn't taken. Gauge('h', 'help', registry=registry) + Info('i', 'help', registry=registry) + self.assertRaises(ValueError, Gauge, 'i_info', 'help', registry=registry) + def test_unregister_works(self): registry = CollectorRegistry() s = Summary('s', 'help', registry=registry) @@ -696,6 +699,34 @@ def test_restricted_registry(self): m.samples = [Sample('s_sum', {}, 7)] self.assertEquals([m], registry.restricted_registry(['s_sum']).collect()) + def test_target_info_injected(self): + registry = CollectorRegistry(target_info={'foo': 'bar'}) + self.assertEqual(1, registry.get_sample_value('target_info', {'foo': 'bar'})) + + def test_target_info_duplicate_detected(self): + registry = CollectorRegistry(target_info={'foo': 'bar'}) + self.assertRaises(ValueError, Info, 'target', 'help', registry=registry) + + registry.set_target_info({}) + i = Info('target', 'help', registry=registry) + registry.set_target_info({}) + self.assertRaises(ValueError, Info, 'target', 'help', registry=registry) + self.assertRaises(ValueError, registry.set_target_info, {'foo': 'bar'}) + registry.unregister(i) + registry.set_target_info({'foo': 'bar'}) + + def test_target_info_restricted_registry(self): + registry = CollectorRegistry(target_info={'foo': 'bar'}) + Summary('s', 'help', registry=registry).observe(7) + + m = Metric('s', 'help', 'summary') + m.samples = [Sample('s_sum', {}, 7)] + self.assertEquals([m], registry.restricted_registry(['s_sum']).collect()) + + m = Metric('target', 'Target metadata', 'info') + m.samples = [Sample('target_info', {'foo': 'bar'}, 1)] + self.assertEquals([m], registry.restricted_registry(['target_info']).collect()) + if __name__ == '__main__': unittest.main()

[ { "components": [ { "doc": "", "lines": [ 119, 127 ], "name": "CollectorRegistry.set_target_info", "signature": "def set_target_info(self, labels):", "type": "function" }, { "doc": "", "lines": [ 129,...

[ "tests/test_core.py::TestCollectorRegistry::test_target_info_duplicate_detected", "tests/test_core.py::TestCollectorRegistry::test_target_info_injected", "tests/test_core.py::TestCollectorRegistry::test_target_info_restricted_registry" ]

[ "tests/test_core.py::TestCounter::test_block_decorator", "tests/test_core.py::TestCounter::test_count_exceptions_not_observable", "tests/test_core.py::TestCounter::test_function_decorator", "tests/test_core.py::TestCounter::test_increment", "tests/test_core.py::TestCounter::test_negative_increment_raises", ...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add target_info to registries This allows target labels as needed by push-based systems to be provided, in a way that doesn't mess up Prometheus's own top-down pull based approach to SD. @SuperQ @RichiH @robskillington @sumeer Here's roughly what I'm thinking. Needs unittests etc. @beorn7 Your input would be appreciated on the pgw front. https://github.com/OpenObservability/OpenMetrics/issues/63 is the general background. Pgw could continue to do this out of band for grouping labels (potentially with the client library using this as a default), or have this as an option. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in prometheus_client/registry.py] (definition of CollectorRegistry.set_target_info:) def set_target_info(self, labels): (definition of CollectorRegistry.get_target_info:) def get_target_info(self): (definition of CollectorRegistry._target_info_metric:) def _target_info_metric(self): [end of new definitions in prometheus_client/registry.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

09a5ae30602a7a81f6174dae4ba08b93ee7feed2

scikit-learn__scikit-learn-14593

14,593

scikit-learn/scikit-learn

0.22

66b0f5fed84d15b63943571e7b124d02763ef3ca

2019-08-07T20:35:07Z

diff --git a/doc/whats_new/v0.22.rst b/doc/whats_new/v0.22.rst index 2b4b0810b8fc3..3a5290dae81fb 100644 --- a/doc/whats_new/v0.22.rst +++ b/doc/whats_new/v0.22.rst @@ -348,6 +348,11 @@ Changelog - |Enhancement| :class:`model_selection.RandomizedSearchCV` now accepts lists of parameter distributions. :pr:`14549` by `Andreas Müller`_. +- |Efficiency| Improved performance of multimetric scoring in + :func:`model_selection.cross_validate`, + :class:`model_selection.GridSearchCV`, and + :class:`model_selection.RandomizedSearchCV`. :pr:`14593` by `Thomas Fan`_. + - |Fix| Reimplemented :class:`model_selection.StratifiedKFold` to fix an issue where one test set could be `n_classes` larger than another. Test sets should now be near-equally sized. :pr:`14704` by `Joel Nothman`_. diff --git a/sklearn/metrics/scorer.py b/sklearn/metrics/scorer.py index 0214c07a21375..daf8b9e11c09d 100644 --- a/sklearn/metrics/scorer.py +++ b/sklearn/metrics/scorer.py @@ -18,8 +18,9 @@ # Arnaud Joly <arnaud.v.joly@gmail.com> # License: Simplified BSD -from abc import ABCMeta from collections.abc import Iterable +from functools import partial +from collections import Counter import numpy as np @@ -44,7 +45,82 @@ from ..base import is_regressor -class _BaseScorer(metaclass=ABCMeta): +def _cached_call(cache, estimator, method, *args, **kwargs): + """Call estimator with method and args and kwargs.""" + if cache is None: + return getattr(estimator, method)(*args, **kwargs) + + try: + return cache[method] + except KeyError: + result = getattr(estimator, method)(*args, **kwargs) + cache[method] = result + return result + + +class _MultimetricScorer: + """Callable for multimetric scoring used to avoid repeated calls + to `predict_proba`, `predict`, and `decision_function`. + + `_MultimetricScorer` will return a dictionary of scores corresponding to + the scorers in the dictionary. Note that `_MultimetricScorer` can be + created with a dictionary with one key (i.e. only one actual scorer). + + Parameters + ---------- + scorers : dict + Dictionary mapping names to callable scorers. + """ + def __init__(self, **scorers): + self._scorers = scorers + + def __call__(self, estimator, *args, **kwargs): + """Evaluate predicted target values.""" + scores = {} + cache = {} if self._use_cache(estimator) else None + cached_call = partial(_cached_call, cache) + + for name, scorer in self._scorers.items(): + if isinstance(scorer, _BaseScorer): + score = scorer._score(cached_call, estimator, + *args, **kwargs) + else: + score = scorer(estimator, *args, **kwargs) + scores[name] = score + return scores + + def _use_cache(self, estimator): + """Return True if using a cache is beneficial. + + Caching may be beneficial when one of these conditions holds: + - `_ProbaScorer` will be called twice. + - `_PredictScorer` will be called twice. + - `_ThresholdScorer` will be called twice. + - `_ThresholdScorer` and `_PredictScorer` are called and + estimator is a regressor. + - `_ThresholdScorer` and `_ProbaScorer` are called and + estimator does not have a `decision_function` attribute. + + """ + if len(self._scorers) == 1: # Only one scorer + return False + + counter = Counter([type(v) for v in self._scorers.values()]) + + if any(counter[known_type] > 1 for known_type in + [_PredictScorer, _ProbaScorer, _ThresholdScorer]): + return True + + if counter[_ThresholdScorer]: + if is_regressor(estimator) and counter[_PredictScorer]: + return True + elif (counter[_ProbaScorer] and + not hasattr(estimator, "decision_function")): + return True + return False + + +class _BaseScorer: def __init__(self, score_func, sign, kwargs): self._kwargs = kwargs self._score_func = score_func @@ -58,17 +134,47 @@ def __repr__(self): "" if self._sign > 0 else ", greater_is_better=False", self._factory_args(), kwargs_string)) + def __call__(self, estimator, X, y_true, sample_weight=None): + """Evaluate predicted target values for X relative to y_true. + + Parameters + ---------- + estimator : object + Trained estimator to use for scoring. Must have a predict_proba + method; the output of that is used to compute the score. + + X : array-like or sparse matrix + Test data that will be fed to estimator.predict. + + y_true : array-like + Gold standard target values for X. + + sample_weight : array-like, optional (default=None) + Sample weights. + + Returns + ------- + score : float + Score function applied to prediction of estimator on X. + """ + return self._score(partial(_cached_call, None), estimator, X, y_true, + sample_weight=sample_weight) + def _factory_args(self): """Return non-default make_scorer arguments for repr.""" return "" class _PredictScorer(_BaseScorer): - def __call__(self, estimator, X, y_true, sample_weight=None): + def _score(self, method_caller, estimator, X, y_true, sample_weight=None): """Evaluate predicted target values for X relative to y_true. Parameters ---------- + method_caller : callable + Returns predictions given an estimator, method name, and other + arguments, potentially caching results. + estimator : object Trained estimator to use for scoring. Must have a predict_proba method; the output of that is used to compute the score. @@ -87,8 +193,7 @@ def __call__(self, estimator, X, y_true, sample_weight=None): score : float Score function applied to prediction of estimator on X. """ - - y_pred = estimator.predict(X) + y_pred = method_caller(estimator, "predict", X) if sample_weight is not None: return self._sign * self._score_func(y_true, y_pred, sample_weight=sample_weight, @@ -99,11 +204,15 @@ def __call__(self, estimator, X, y_true, sample_weight=None): class _ProbaScorer(_BaseScorer): - def __call__(self, clf, X, y, sample_weight=None): + def _score(self, method_caller, clf, X, y, sample_weight=None): """Evaluate predicted probabilities for X relative to y_true. Parameters ---------- + method_caller : callable + Returns predictions given an estimator, method name, and other + arguments, potentially caching results. + clf : object Trained classifier to use for scoring. Must have a predict_proba method; the output of that is used to compute the score. @@ -124,7 +233,7 @@ def __call__(self, clf, X, y, sample_weight=None): Score function applied to prediction of estimator on X. """ y_type = type_of_target(y) - y_pred = clf.predict_proba(X) + y_pred = method_caller(clf, "predict_proba", X) if y_type == "binary": if y_pred.shape[1] == 2: y_pred = y_pred[:, 1] @@ -145,11 +254,15 @@ def _factory_args(self): class _ThresholdScorer(_BaseScorer): - def __call__(self, clf, X, y, sample_weight=None): + def _score(self, method_caller, clf, X, y, sample_weight=None): """Evaluate decision function output for X relative to y_true. Parameters ---------- + method_caller : callable + Returns predictions given an estimator, method name, and other + arguments, potentially caching results. + clf : object Trained classifier to use for scoring. Must have either a decision_function method or a predict_proba method; the output of @@ -176,17 +289,17 @@ def __call__(self, clf, X, y, sample_weight=None): raise ValueError("{0} format is not supported".format(y_type)) if is_regressor(clf): - y_pred = clf.predict(X) + y_pred = method_caller(clf, "predict", X) else: try: - y_pred = clf.decision_function(X) + y_pred = method_caller(clf, "decision_function", X) # For multi-output multi-class estimator if isinstance(y_pred, list): y_pred = np.vstack([p for p in y_pred]).T except (NotImplementedError, AttributeError): - y_pred = clf.predict_proba(X) + y_pred = method_caller(clf, "predict_proba", X) if y_type == "binary": if y_pred.shape[1] == 2: diff --git a/sklearn/model_selection/_validation.py b/sklearn/model_selection/_validation.py index 66ed73abf96a9..e9374e23c48ca 100644 --- a/sklearn/model_selection/_validation.py +++ b/sklearn/model_selection/_validation.py @@ -14,6 +14,7 @@ import numbers import time from traceback import format_exception_only +from contextlib import suppress import numpy as np import scipy.sparse as sp @@ -24,7 +25,8 @@ _message_with_time) from ..utils.validation import _is_arraylike, _num_samples from ..utils.metaestimators import _safe_split -from ..metrics.scorer import check_scoring, _check_multimetric_scoring +from ..metrics.scorer import (check_scoring, _check_multimetric_scoring, + _MultimetricScorer) from ..exceptions import FitFailedWarning from ._split import check_cv from ..preprocessing import LabelEncoder @@ -493,8 +495,6 @@ def _fit_and_score(estimator, X, y, scorer, train, test, verbose, X_train, y_train = _safe_split(estimator, X, y, train) X_test, y_test = _safe_split(estimator, X, y, test, train) - is_multimetric = not callable(scorer) - n_scorers = len(scorer.keys()) if is_multimetric else 1 try: if y_train is None: estimator.fit(X_train, **fit_params) @@ -508,12 +508,10 @@ def _fit_and_score(estimator, X, y, scorer, train, test, verbose, if error_score == 'raise': raise elif isinstance(error_score, numbers.Number): - if is_multimetric: - test_scores = dict(zip(scorer.keys(), - [error_score, ] * n_scorers)) + if isinstance(scorer, dict): + test_scores = {name: error_score for name in scorer} if return_train_score: - train_scores = dict(zip(scorer.keys(), - [error_score, ] * n_scorers)) + train_scores = test_scores.copy() else: test_scores = error_score if return_train_score: @@ -530,14 +528,12 @@ def _fit_and_score(estimator, X, y, scorer, train, test, verbose, else: fit_time = time.time() - start_time - # _score will return dict if is_multimetric is True - test_scores = _score(estimator, X_test, y_test, scorer, is_multimetric) + test_scores = _score(estimator, X_test, y_test, scorer) score_time = time.time() - start_time - fit_time if return_train_score: - train_scores = _score(estimator, X_train, y_train, scorer, - is_multimetric) + train_scores = _score(estimator, X_train, y_train, scorer) if verbose > 2: - if is_multimetric: + if isinstance(test_scores, dict): for scorer_name in sorted(test_scores): msg += ", %s=" % scorer_name if return_train_score: @@ -567,58 +563,38 @@ def _fit_and_score(estimator, X, y, scorer, train, test, verbose, return ret -def _score(estimator, X_test, y_test, scorer, is_multimetric=False): +def _score(estimator, X_test, y_test, scorer): """Compute the score(s) of an estimator on a given test set. - Will return a single float if is_multimetric is False and a dict of floats, - if is_multimetric is True + Will return a dict of floats if `scorer` is a dict, otherwise a single + float is returned. """ - if is_multimetric: - return _multimetric_score(estimator, X_test, y_test, scorer) + if isinstance(scorer, dict): + # will cache method calls if needed. scorer() returns a dict + scorer = _MultimetricScorer(**scorer) + if y_test is None: + scores = scorer(estimator, X_test) else: - if y_test is None: - score = scorer(estimator, X_test) - else: - score = scorer(estimator, X_test, y_test) - - if hasattr(score, 'item'): - try: - # e.g. unwrap memmapped scalars - score = score.item() - except ValueError: - # non-scalar? - pass - - if not isinstance(score, numbers.Number): - raise ValueError("scoring must return a number, got %s (%s) " - "instead. (scorer=%r)" - % (str(score), type(score), scorer)) - return score - - -def _multimetric_score(estimator, X_test, y_test, scorers): - """Return a dict of score for multimetric scoring""" - scores = {} - - for name, scorer in scorers.items(): - if y_test is None: - score = scorer(estimator, X_test) - else: - score = scorer(estimator, X_test, y_test) - - if hasattr(score, 'item'): - try: + scores = scorer(estimator, X_test, y_test) + + error_msg = ("scoring must return a number, got %s (%s) " + "instead. (scorer=%s)") + if isinstance(scores, dict): + for name, score in scores.items(): + if hasattr(score, 'item'): + with suppress(ValueError): + # e.g. unwrap memmapped scalars + score = score.item() + if not isinstance(score, numbers.Number): + raise ValueError(error_msg % (score, type(score), name)) + scores[name] = score + else: # scalar + if hasattr(scores, 'item'): + with suppress(ValueError): # e.g. unwrap memmapped scalars - score = score.item() - except ValueError: - # non-scalar? - pass - scores[name] = score - - if not isinstance(score, numbers.Number): - raise ValueError("scoring must return a number, got %s (%s) " - "instead. (scorer=%s)" - % (str(score), type(score), name)) + scores = scores.item() + if not isinstance(scores, numbers.Number): + raise ValueError(error_msg % (scores, type(scores), scorer)) return scores

diff --git a/sklearn/metrics/tests/test_score_objects.py b/sklearn/metrics/tests/test_score_objects.py index 120bae5275281..71f3c80c72409 100644 --- a/sklearn/metrics/tests/test_score_objects.py +++ b/sklearn/metrics/tests/test_score_objects.py @@ -3,11 +3,13 @@ import shutil import os import numbers +from unittest.mock import Mock import numpy as np import pytest import joblib +from numpy.testing import assert_allclose from sklearn.utils.testing import assert_almost_equal from sklearn.utils.testing import assert_array_equal from sklearn.utils.testing import ignore_warnings @@ -18,10 +20,11 @@ jaccard_score) from sklearn.metrics import cluster as cluster_module from sklearn.metrics.scorer import (check_scoring, _PredictScorer, - _passthrough_scorer) + _passthrough_scorer, _MultimetricScorer) from sklearn.metrics import accuracy_score from sklearn.metrics.scorer import _check_multimetric_scoring from sklearn.metrics import make_scorer, get_scorer, SCORERS +from sklearn.neighbors import KNeighborsClassifier from sklearn.svm import LinearSVC from sklearn.pipeline import make_pipeline from sklearn.cluster import KMeans @@ -546,3 +549,112 @@ def test_scoring_is_not_metric(): check_scoring(Ridge(), r2_score) with pytest.raises(ValueError, match='make_scorer'): check_scoring(KMeans(), cluster_module.adjusted_rand_score) + + +@pytest.mark.parametrize( + ("scorers,expected_predict_count," + "expected_predict_proba_count,expected_decision_func_count"), + [({'a1': 'accuracy', 'a2': 'accuracy', + 'll1': 'neg_log_loss', 'll2': 'neg_log_loss', + 'ra1': 'roc_auc', 'ra2': 'roc_auc'}, 1, 1, 1), + (['roc_auc', 'accuracy'], 1, 0, 1), + (['neg_log_loss', 'accuracy'], 1, 1, 0)]) +def test_multimetric_scorer_calls_method_once(scorers, expected_predict_count, + expected_predict_proba_count, + expected_decision_func_count): + X, y = np.array([[1], [1], [0], [0], [0]]), np.array([0, 1, 1, 1, 0]) + + mock_est = Mock() + fit_func = Mock(return_value=mock_est) + predict_func = Mock(return_value=y) + + pos_proba = np.random.rand(X.shape[0]) + proba = np.c_[1 - pos_proba, pos_proba] + predict_proba_func = Mock(return_value=proba) + decision_function_func = Mock(return_value=pos_proba) + + mock_est.fit = fit_func + mock_est.predict = predict_func + mock_est.predict_proba = predict_proba_func + mock_est.decision_function = decision_function_func + + scorer_dict, _ = _check_multimetric_scoring(LogisticRegression(), scorers) + multi_scorer = _MultimetricScorer(**scorer_dict) + results = multi_scorer(mock_est, X, y) + + assert set(scorers) == set(results) # compare dict keys + + assert predict_func.call_count == expected_predict_count + assert predict_proba_func.call_count == expected_predict_proba_count + assert decision_function_func.call_count == expected_decision_func_count + + +def test_multimetric_scorer_calls_method_once_classifier_no_decision(): + predict_proba_call_cnt = 0 + + class MockKNeighborsClassifier(KNeighborsClassifier): + def predict_proba(self, X): + nonlocal predict_proba_call_cnt + predict_proba_call_cnt += 1 + return super().predict_proba(X) + + X, y = np.array([[1], [1], [0], [0], [0]]), np.array([0, 1, 1, 1, 0]) + + # no decision function + clf = MockKNeighborsClassifier(n_neighbors=1) + clf.fit(X, y) + + scorers = ['roc_auc', 'neg_log_loss'] + scorer_dict, _ = _check_multimetric_scoring(clf, scorers) + scorer = _MultimetricScorer(**scorer_dict) + scorer(clf, X, y) + + assert predict_proba_call_cnt == 1 + + +def test_multimetric_scorer_calls_method_once_regressor_threshold(): + predict_called_cnt = 0 + + class MockDecisionTreeRegressor(DecisionTreeRegressor): + def predict(self, X): + nonlocal predict_called_cnt + predict_called_cnt += 1 + return super().predict(X) + + X, y = np.array([[1], [1], [0], [0], [0]]), np.array([0, 1, 1, 1, 0]) + + # no decision function + clf = MockDecisionTreeRegressor() + clf.fit(X, y) + + scorers = {'neg_mse': 'neg_mean_squared_error', 'r2': 'roc_auc'} + scorer_dict, _ = _check_multimetric_scoring(clf, scorers) + scorer = _MultimetricScorer(**scorer_dict) + scorer(clf, X, y) + + assert predict_called_cnt == 1 + + +def test_multimetric_scorer_sanity_check(): + # scoring dictionary returned is the same as calling each scorer seperately + scorers = {'a1': 'accuracy', 'a2': 'accuracy', + 'll1': 'neg_log_loss', 'll2': 'neg_log_loss', + 'ra1': 'roc_auc', 'ra2': 'roc_auc'} + + X, y = make_classification(random_state=0) + + clf = DecisionTreeClassifier() + clf.fit(X, y) + + scorer_dict, _ = _check_multimetric_scoring(clf, scorers) + multi_scorer = _MultimetricScorer(**scorer_dict) + + result = multi_scorer(clf, X, y) + + seperate_scores = { + name: get_scorer(name)(clf, X, y) + for name in ['accuracy', 'neg_log_loss', 'roc_auc']} + + for key, value in result.items(): + score_name = scorers[key] + assert_allclose(value, seperate_scores[score_name])

diff --git a/doc/whats_new/v0.22.rst b/doc/whats_new/v0.22.rst index 2b4b0810b8fc3..3a5290dae81fb 100644 --- a/doc/whats_new/v0.22.rst +++ b/doc/whats_new/v0.22.rst @@ -348,6 +348,11 @@ Changelog - |Enhancement| :class:`model_selection.RandomizedSearchCV` now accepts lists of parameter distributions. :pr:`14549` by `Andreas Müller`_. +- |Efficiency| Improved performance of multimetric scoring in + :func:`model_selection.cross_validate`, + :class:`model_selection.GridSearchCV`, and + :class:`model_selection.RandomizedSearchCV`. :pr:`14593` by `Thomas Fan`_. + - |Fix| Reimplemented :class:`model_selection.StratifiedKFold` to fix an issue where one test set could be `n_classes` larger than another. Test sets should now be near-equally sized. :pr:`14704` by `Joel Nothman`_.

[ { "components": [ { "doc": "Call estimator with method and args and kwargs.", "lines": [ 48, 58 ], "name": "_cached_call", "signature": "def _cached_call(cache, estimator, method, *args, **kwargs):", "type": "function" }, { ...

[ "sklearn/metrics/tests/test_score_objects.py::test_all_scorers_repr", "sklearn/metrics/tests/test_score_objects.py::test_check_scoring_and_check_multimetric_scoring", "sklearn/metrics/tests/test_score_objects.py::test_check_scoring_gridsearchcv", "sklearn/metrics/tests/test_score_objects.py::test_make_scorer"...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG] Adds _MultimetricScorer for Optimized Scoring  #### Reference Issues/PRs  Fixes https://github.com/scikit-learn/scikit-learn/issues/10802 Alternative to https://github.com/scikit-learn/scikit-learn/pull/10979 #### What does this implement/fix? Explain your changes. 1. This PR creates a `_MultimetricScorer` that subclasses dict which is used to reduce the number of calls to `predict`, `predict_proba`, and `decision_function`. 2. The public interface of objects and functions using `scoring` are unchanged. 3. The cache is only used when it is beneficial to use, as defined in `_MultimetricScorer._use_cache`. 4. Users can not create a `_MultimetricScorer` and pass it into `scoring`. #### Any other comments? I do have plans to support custom callables that return dictionaries from the user. This was not included in this PR to narrow the scope of this PR to `_MultimetricScorer`.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/metrics/scorer.py] (definition of _cached_call:) def _cached_call(cache, estimator, method, *args, **kwargs): """Call estimator with method and args and kwargs.""" (definition of _MultimetricScorer:) class _MultimetricScorer: """Callable for multimetric scoring used to avoid repeated calls to `predict_proba`, `predict`, and `decision_function`. `_MultimetricScorer` will return a dictionary of scores corresponding to the scorers in the dictionary. Note that `_MultimetricScorer` can be created with a dictionary with one key (i.e. only one actual scorer). Parameters ---------- scorers : dict Dictionary mapping names to callable scorers.""" (definition of _MultimetricScorer.__init__:) def __init__(self, **scorers): (definition of _MultimetricScorer.__call__:) def __call__(self, estimator, *args, **kwargs): """Evaluate predicted target values.""" (definition of _MultimetricScorer._use_cache:) def _use_cache(self, estimator): """Return True if using a cache is beneficial. Caching may be beneficial when one of these conditions holds: - `_ProbaScorer` will be called twice. - `_PredictScorer` will be called twice. - `_ThresholdScorer` will be called twice. - `_ThresholdScorer` and `_PredictScorer` are called and estimator is a regressor. - `_ThresholdScorer` and `_ProbaScorer` are called and estimator does not have a `decision_function` attribute.""" (definition of _BaseScorer.__call__:) def __call__(self, estimator, X, y_true, sample_weight=None): """Evaluate predicted target values for X relative to y_true. Parameters ---------- estimator : object Trained estimator to use for scoring. Must have a predict_proba method; the output of that is used to compute the score. X : array-like or sparse matrix Test data that will be fed to estimator.predict. y_true : array-like Gold standard target values for X. sample_weight : array-like, optional (default=None) Sample weights. Returns ------- score : float Score function applied to prediction of estimator on X.""" (definition of _PredictScorer._score:) def _score(self, method_caller, estimator, X, y_true, sample_weight=None): """Evaluate predicted target values for X relative to y_true. Parameters ---------- method_caller : callable Returns predictions given an estimator, method name, and other arguments, potentially caching results. estimator : object Trained estimator to use for scoring. Must have a predict_proba method; the output of that is used to compute the score. X : array-like or sparse matrix Test data that will be fed to estimator.predict. y_true : array-like Gold standard target values for X. sample_weight : array-like, optional (default=None) Sample weights. Returns ------- score : float Score function applied to prediction of estimator on X.""" (definition of _ProbaScorer._score:) def _score(self, method_caller, clf, X, y, sample_weight=None): """Evaluate predicted probabilities for X relative to y_true. Parameters ---------- method_caller : callable Returns predictions given an estimator, method name, and other arguments, potentially caching results. clf : object Trained classifier to use for scoring. Must have a predict_proba method; the output of that is used to compute the score. X : array-like or sparse matrix Test data that will be fed to clf.predict_proba. y : array-like Gold standard target values for X. These must be class labels, not probabilities. sample_weight : array-like, optional (default=None) Sample weights. Returns ------- score : float Score function applied to prediction of estimator on X.""" (definition of _ThresholdScorer._score:) def _score(self, method_caller, clf, X, y, sample_weight=None): """Evaluate decision function output for X relative to y_true. Parameters ---------- method_caller : callable Returns predictions given an estimator, method name, and other arguments, potentially caching results. clf : object Trained classifier to use for scoring. Must have either a decision_function method or a predict_proba method; the output of that is used to compute the score. X : array-like or sparse matrix Test data that will be fed to clf.decision_function or clf.predict_proba. y : array-like Gold standard target values for X. These must be class labels, not decision function values. sample_weight : array-like, optional (default=None) Sample weights. Returns ------- score : float Score function applied to prediction of estimator on X.""" [end of new definitions in sklearn/metrics/scorer.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c96e0958da46ebef482a4084cdda3285d5f5ad23

sympy__sympy-17308

17,308

sympy/sympy

1.5

1e211112f489713902a67c6f03339f44ebc24326

2019-07-31T18:36:02Z

diff --git a/sympy/tensor/array/arrayop.py b/sympy/tensor/array/arrayop.py index 1d22255a35c0..273897b5f4bc 100644 --- a/sympy/tensor/array/arrayop.py +++ b/sympy/tensor/array/arrayop.py @@ -1,10 +1,13 @@ import itertools -from sympy import S, Tuple, diff +from sympy import S, Tuple, diff, Basic from sympy.core.compatibility import Iterable from sympy.tensor.array import ImmutableDenseNDimArray from sympy.tensor.array.ndim_array import NDimArray +from sympy.tensor.array.dense_ndim_array import DenseNDimArray +from sympy.tensor.array.sparse_ndim_array import SparseNDimArray + def _arrayfy(a): from sympy.matrices import MatrixBase @@ -62,10 +65,7 @@ def tensorproduct(*args): new_array = {k1*lp + k2: v1*v2 for k1, v1 in a._sparse_array.items() for k2, v2 in b._sparse_array.items()} return ImmutableSparseNDimArray(new_array, a.shape + b.shape) - al = list(a) - bl = list(b) - - product_list = [i*j for i in al for j in bl] + product_list = [i*j for i in Flatten(a) for j in Flatten(b)] return ImmutableDenseNDimArray(product_list, a.shape + b.shape) @@ -215,16 +215,16 @@ def derive_by_array(expr, dx): if isinstance(expr, SparseNDimArray): lp = len(expr) new_array = {k + i*lp: v - for i, x in enumerate(dx) + for i, x in enumerate(Flatten(dx)) for k, v in expr.diff(x)._sparse_array.items()} else: - new_array = [[y.diff(x) for y in expr] for x in dx] + new_array = [[y.diff(x) for y in Flatten(expr)] for x in Flatten(dx)] return type(expr)(new_array, dx.shape + expr.shape) else: return expr.diff(dx) else: if isinstance(dx, array_types): - return ImmutableDenseNDimArray([expr.diff(i) for i in dx], dx.shape) + return ImmutableDenseNDimArray([expr.diff(i) for i in Flatten(dx)], dx.shape) else: return diff(expr, dx) @@ -296,3 +296,73 @@ def permutedims(expr, perm): new_array[i] = expr[t] return type(expr)(new_array, new_shape) + + +class Flatten(Basic): + ''' + Flatten an iterable object to a list in a lazy-evaluation way. + + Notes + ===== + + This class is an iterator with which the memory cost can be economised. + Optimisation has been considered to ameliorate the performance for some + specific data types like DenseNDimArray and SparseNDimArray. + + Examples + ======== + + >>> from sympy.tensor.array.arrayop import Flatten + >>> from sympy.tensor.array import Array + >>> A = Array(range(6)).reshape(2, 3) + >>> Flatten(A) + Flatten([[0, 1, 2], [3, 4, 5]]) + >>> [i for i in Flatten(A)] + [0, 1, 2, 3, 4, 5] + ''' + def __init__(self, iterable): + from sympy.matrices.matrices import MatrixBase + from sympy.tensor.array import NDimArray + + if not isinstance(iterable, (Iterable, MatrixBase)): + raise NotImplementedError("Data type not yet supported") + + if isinstance(iterable, list): + iterable = NDimArray(iterable) + + self._iter = iterable + self._idx = 0 + + def __iter__(self): + return self + + def __next__(self): + from sympy.matrices.matrices import MatrixBase + + if len(self._iter) > self._idx: + if isinstance(self._iter, DenseNDimArray): + result = self._iter._array[self._idx] + + elif isinstance(self._iter, SparseNDimArray): + if self._idx in self._iter._sparse_array: + result = self._iter._sparse_array[self._idx] + else: + result = 0 + + elif isinstance(self._iter, MatrixBase): + result = self._iter[self._idx] + + elif hasattr(self._iter, '__next__'): + result = next(self._iter) + + else: + result = self._iter[self._idx] + + else: + raise StopIteration + + self._idx += 1 + return result + + def next(self): + return self.__next__() diff --git a/sympy/tensor/array/dense_ndim_array.py b/sympy/tensor/array/dense_ndim_array.py index ccae6f8b4a77..3cb7be896c75 100644 --- a/sympy/tensor/array/dense_ndim_array.py +++ b/sympy/tensor/array/dense_ndim_array.py @@ -52,9 +52,10 @@ def __getitem__(self, index): if syindex is not None: return syindex - if isinstance(index, (SYMPY_INTS, Integer)): + if isinstance(index, (SYMPY_INTS, Integer, slice)): index = (index, ) - if not isinstance(index, slice) and len(index) < self.rank(): + + if len(index) < self.rank(): index = tuple([i for i in index] + \ [slice(None) for i in range(len(index), self.rank())]) @@ -64,11 +65,8 @@ def __getitem__(self, index): nshape = [len(el) for i, el in enumerate(sl_factors) if isinstance(index[i], slice)] return type(self)(array, nshape) else: - if isinstance(index, slice): - return self._array[index] - else: - index = self._parse_index(index) - return self._array[index] + index = self._parse_index(index) + return self._array[index] @classmethod def zeros(cls, *shape): @@ -99,12 +97,6 @@ def tomatrix(self): return Matrix(self.shape[0], self.shape[1], self._array) - def __iter__(self): - def iterator(): - for i in range(self._loop_size): - yield self[self._get_tuple_index(i)] - return iterator() - def reshape(self, *newshape): """ Returns MutableDenseNDimArray instance with new shape. Elements number diff --git a/sympy/tensor/array/ndim_array.py b/sympy/tensor/array/ndim_array.py index 38010407de9c..379270089f30 100644 --- a/sympy/tensor/array/ndim_array.py +++ b/sympy/tensor/array/ndim_array.py @@ -140,10 +140,7 @@ def _handle_ndarray_creation_inputs(cls, iterable=None, shape=None, **kwargs): # Construction of a sparse array from a sparse array elif isinstance(iterable, SparseNDimArray): return iterable._shape, iterable._sparse_array - # Construction from another `NDimArray`: - elif isinstance(iterable, NDimArray): - shape = iterable.shape - iterable = list(iterable) + # Construct N-dim array from an iterable (numpy arrays included): elif isinstance(iterable, Iterable): iterable, shape = cls._scan_iterable_shape(iterable) @@ -286,11 +283,12 @@ def applyfunc(self, f): [[0, 2], [4, 6]] """ from sympy.tensor.array import SparseNDimArray + from sympy.tensor.array.arrayop import Flatten if isinstance(self, SparseNDimArray) and f(S.Zero) == 0: return type(self)({k: f(v) for k, v in self._sparse_array.items() if f(v) != 0}, self.shape) - return type(self)(map(f, self), self.shape) + return type(self)(map(f, Flatten(self)), self.shape) def __str__(self): """Returns string, allows to use standard functions print() and str(). @@ -366,28 +364,33 @@ def f(sh, shape_left, i, j): return f(self._loop_size, self.shape, 0, self._loop_size) def __add__(self, other): + from sympy.tensor.array.arrayop import Flatten + if not isinstance(other, NDimArray): raise TypeError(str(other)) if self.shape != other.shape: raise ValueError("array shape mismatch") - result_list = [i+j for i,j in zip(self, other)] + result_list = [i+j for i,j in zip(Flatten(self), Flatten(other))] return type(self)(result_list, self.shape) def __sub__(self, other): + from sympy.tensor.array.arrayop import Flatten + if not isinstance(other, NDimArray): raise TypeError(str(other)) if self.shape != other.shape: raise ValueError("array shape mismatch") - result_list = [i-j for i,j in zip(self, other)] + result_list = [i-j for i,j in zip(Flatten(self), Flatten(other))] return type(self)(result_list, self.shape) def __mul__(self, other): from sympy.matrices.matrices import MatrixBase from sympy.tensor.array import SparseNDimArray + from sympy.tensor.array.arrayop import Flatten if isinstance(other, (Iterable, NDimArray, MatrixBase)): raise ValueError("scalar expected, use tensorproduct(...) for tensorial product") @@ -398,12 +401,13 @@ def __mul__(self, other): return type(self)({}, self.shape) return type(self)({k: other*v for (k, v) in self._sparse_array.items()}, self.shape) - result_list = [i*other for i in self] + result_list = [i*other for i in Flatten(self)] return type(self)(result_list, self.shape) def __rmul__(self, other): from sympy.matrices.matrices import MatrixBase from sympy.tensor.array import SparseNDimArray + from sympy.tensor.array.arrayop import Flatten if isinstance(other, (Iterable, NDimArray, MatrixBase)): raise ValueError("scalar expected, use tensorproduct(...) for tensorial product") @@ -414,12 +418,13 @@ def __rmul__(self, other): return type(self)({}, self.shape) return type(self)({k: other*v for (k, v) in self._sparse_array.items()}, self.shape) - result_list = [other*i for i in self] + result_list = [other*i for i in Flatten(self)] return type(self)(result_list, self.shape) def __div__(self, other): from sympy.matrices.matrices import MatrixBase from sympy.tensor.array import SparseNDimArray + from sympy.tensor.array.arrayop import Flatten if isinstance(other, (Iterable, NDimArray, MatrixBase)): raise ValueError("scalar expected") @@ -428,7 +433,7 @@ def __div__(self, other): if isinstance(self, SparseNDimArray) and other != S.Zero: return type(self)({k: v/other for (k, v) in self._sparse_array.items()}, self.shape) - result_list = [i/other for i in self] + result_list = [i/other for i in Flatten(self)] return type(self)(result_list, self.shape) def __rdiv__(self, other): @@ -436,13 +441,24 @@ def __rdiv__(self, other): def __neg__(self): from sympy.tensor.array import SparseNDimArray + from sympy.tensor.array.arrayop import Flatten if isinstance(self, SparseNDimArray): return type(self)({k: -v for (k, v) in self._sparse_array.items()}, self.shape) - result_list = [-i for i in self] + result_list = [-i for i in Flatten(self)] return type(self)(result_list, self.shape) + def __iter__(self): + def iterator(): + if self._shape: + for i in range(self._shape[0]): + yield self[i] + else: + yield self[()] + + return iterator() + def __eq__(self, other): """ NDimArray instances can be compared to each other. @@ -492,7 +508,9 @@ def transpose(self): return self._eval_transpose() def _eval_conjugate(self): - return self.func([i.conjugate() for i in self], self.shape) + from sympy.tensor.array.arrayop import Flatten + + return self.func([i.conjugate() for i in Flatten(self)], self.shape) def conjugate(self): return self._eval_conjugate() diff --git a/sympy/tensor/array/sparse_ndim_array.py b/sympy/tensor/array/sparse_ndim_array.py index 4084668f219e..6c0124fb739a 100644 --- a/sympy/tensor/array/sparse_ndim_array.py +++ b/sympy/tensor/array/sparse_ndim_array.py @@ -50,9 +50,10 @@ def __getitem__(self, index): if syindex is not None: return syindex - if isinstance(index, (SYMPY_INTS, Integer)): + if isinstance(index, (SYMPY_INTS, Integer, slice)): index = (index, ) - if not isinstance(index, slice) and len(index) < self.rank(): + + if len(index) < self.rank(): index = tuple([i for i in index] + \ [slice(None) for i in range(len(index), self.rank())]) @@ -63,15 +64,8 @@ def __getitem__(self, index): nshape = [len(el) for i, el in enumerate(sl_factors) if isinstance(index[i], slice)] return type(self)(array, nshape) else: - # `index` is a single slice: - if isinstance(index, slice): - start, stop, step = index.indices(self._loop_size) - retvec = [self._sparse_array.get(ind, S.Zero) for ind in range(start, stop, step)] - return retvec - # `index` is a number or a tuple without any slice: - else: - index = self._parse_index(index) - return self._sparse_array.get(index, S.Zero) + index = self._parse_index(index) + return self._sparse_array.get(index, S.Zero) @classmethod def zeros(cls, *shape): @@ -106,12 +100,6 @@ def tomatrix(self): return SparseMatrix(self.shape[0], self.shape[1], mat_sparse) - def __iter__(self): - def iterator(): - for i in range(self._loop_size): - yield self[self._get_tuple_index(i)] - return iterator() - def reshape(self, *newshape): new_total_size = functools.reduce(lambda x,y: x*y, newshape) if new_total_size != self._loop_size: diff --git a/sympy/tensor/tensor.py b/sympy/tensor/tensor.py index 555d50b6f1a8..2a222f245e7e 100644 --- a/sympy/tensor/tensor.py +++ b/sympy/tensor/tensor.py @@ -524,6 +524,7 @@ def _assign_data_to_tensor_expr(self, key, data): def _check_permutations_on_data(self, tens, data): from .array import permutedims + from .array.arrayop import Flatten if isinstance(tens, TensorHead): rank = tens.rank @@ -548,7 +549,7 @@ def _check_permutations_on_data(self, tens, data): for i in range(gener.order()-1): data_swapped = permutedims(data_swapped, permute_axes) # if any value in the difference array is non-zero, raise an error: - if any(last_data - sign_change*data_swapped): + if any(Flatten(last_data - sign_change*data_swapped)): raise ValueError("Component data symmetry structure error") last_data = data_swapped diff --git a/sympy/utilities/iterables.py b/sympy/utilities/iterables.py index 9ff2f61d2de7..d94a872eb8a9 100644 --- a/sympy/utilities/iterables.py +++ b/sympy/utilities/iterables.py @@ -55,6 +55,7 @@ def flatten(iterable, levels=None, cls=None): adapted from https://kogs-www.informatik.uni-hamburg.de/~meine/python_tricks """ + from sympy.tensor.array import NDimArray if levels is not None: if not levels: return iterable @@ -73,7 +74,7 @@ def flatten(iterable, levels=None, cls=None): for el in iterable: if reducible(el): - if hasattr(el, 'args'): + if hasattr(el, 'args') and not isinstance(el, NDimArray): el = el.args result.extend(flatten(el, levels=levels, cls=cls)) else:

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 20b421f5fd7c..9a7c0eda4a42 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -3982,6 +3982,12 @@ def test_sympy__tensor__array__array_comprehension__ArrayComprehension(): arrcom = ArrayComprehension(x, (x, 1, 5)) assert _test_args(arrcom) +def test_sympy__tensor__array__arrayop__Flatten(): + from sympy.tensor.array.arrayop import Flatten + from sympy.tensor.array.dense_ndim_array import ImmutableDenseNDimArray + fla = Flatten(ImmutableDenseNDimArray(range(24)).reshape(2, 3, 4)) + assert _test_args(fla) + def test_sympy__tensor__functions__TensorProduct(): from sympy.tensor.functions import TensorProduct diff --git a/sympy/tensor/array/tests/test_arrayop.py b/sympy/tensor/array/tests/test_arrayop.py index a6510aca87d5..f42cdd3d44cd 100644 --- a/sympy/tensor/array/tests/test_arrayop.py +++ b/sympy/tensor/array/tests/test_arrayop.py @@ -7,7 +7,7 @@ from sympy import symbols, sin, exp, log, cos, transpose, adjoint, conjugate, diff from sympy.tensor.array import Array, ImmutableDenseNDimArray, ImmutableSparseNDimArray, MutableSparseNDimArray -from sympy.tensor.array import tensorproduct, tensorcontraction, derive_by_array, permutedims +from sympy.tensor.array.arrayop import tensorproduct, tensorcontraction, derive_by_array, permutedims, Flatten # Test import although not used in file from sympy.tensor.array import NDimArray @@ -285,3 +285,12 @@ def test_array_permutedims(): assert permutedims(A, (1, 0, 2)) == SparseArrayType({1: 1, 100000000: 2}, (20000, 10000, 10000)) B = SparseArrayType({1:1, 20000:2}, (10000, 20000)) assert B.transpose() == SparseArrayType({10000: 1, 1: 2}, (20000, 10000)) + +def test_flatten(): + from sympy import Matrix + for ArrayType in [ImmutableDenseNDimArray, ImmutableSparseNDimArray, Matrix]: + A = ArrayType(range(24)).reshape(4, 6) + assert [i for i in Flatten(A)] == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23] + + for i, v in enumerate(Flatten(A)): + i == v diff --git a/sympy/tensor/array/tests/test_immutable_ndim_array.py b/sympy/tensor/array/tests/test_immutable_ndim_array.py index 7b7bb402c84d..e4001e98508d 100644 --- a/sympy/tensor/array/tests/test_immutable_ndim_array.py +++ b/sympy/tensor/array/tests/test_immutable_ndim_array.py @@ -24,13 +24,13 @@ def test_ndim_array_initiation(): arr_with_one_element = ImmutableDenseNDimArray([23]) assert len(arr_with_one_element) == 1 assert arr_with_one_element[0] == 23 - assert arr_with_one_element[:] == [23] + assert arr_with_one_element[:] == ImmutableDenseNDimArray([23]) assert arr_with_one_element.rank() == 1 arr_with_symbol_element = ImmutableDenseNDimArray([Symbol('x')]) assert len(arr_with_symbol_element) == 1 assert arr_with_symbol_element[0] == Symbol('x') - assert arr_with_symbol_element[:] == [Symbol('x')] + assert arr_with_symbol_element[:] == ImmutableDenseNDimArray([Symbol('x')]) assert arr_with_symbol_element.rank() == 1 number5 = 5 @@ -123,10 +123,8 @@ def test_getitem(): def test_iterator(): array = ImmutableDenseNDimArray(range(4), (2, 2)) - j = 0 - for i in array: - assert i == j - j += 1 + array[0] == ImmutableDenseNDimArray([0, 1]) + array[1] == ImmutableDenseNDimArray([2, 3]) array = array.reshape(4) j = 0 @@ -141,10 +139,10 @@ def test_sparse(): # dictionary where all data is, only non-zero entries are actually stored: assert len(sparse_array._sparse_array) == 1 - assert list(sparse_array) == [0, 0, 0, 1] + assert sparse_array.tolist() == [[0, 0], [0, 1]] - for i, j in zip(sparse_array, [0, 0, 0, 1]): - assert i == j + for i, j in zip(sparse_array, [[0, 0], [0, 1]]): + assert i == ImmutableSparseNDimArray(j) def sparse_assignment(): sparse_array[0, 0] = 123 @@ -180,14 +178,14 @@ def test_calculation(): c = a + b for i in c: - assert i == 10 + assert i == ImmutableDenseNDimArray([10, 10, 10]) assert c == ImmutableDenseNDimArray([10]*9, (3, 3)) assert c == ImmutableSparseNDimArray([10]*9, (3, 3)) c = b - a for i in c: - assert i == 8 + assert i == ImmutableDenseNDimArray([8, 8, 8]) assert c == ImmutableDenseNDimArray([8]*9, (3, 3)) assert c == ImmutableSparseNDimArray([8]*9, (3, 3)) @@ -333,7 +331,7 @@ def test_rebuild_immutable_arrays(): def test_slices(): md = ImmutableDenseNDimArray(range(10, 34), (2, 3, 4)) - assert md[:] == md._array + assert md[:] == ImmutableDenseNDimArray(range(10, 34), (2, 3, 4)) assert md[:, :, 0].tomatrix() == Matrix([[10, 14, 18], [22, 26, 30]]) assert md[0, 1:2, :].tomatrix() == Matrix([[14, 15, 16, 17]]) assert md[0, 1:3, :].tomatrix() == Matrix([[14, 15, 16, 17], [18, 19, 20, 21]]) @@ -342,8 +340,7 @@ def test_slices(): sd = ImmutableSparseNDimArray(range(10, 34), (2, 3, 4)) assert sd == ImmutableSparseNDimArray(md) - assert sd[:] == md._array - assert sd[:] == list(sd) + assert sd[:] == ImmutableSparseNDimArray(range(10, 34), (2, 3, 4)) assert sd[:, :, 0].tomatrix() == Matrix([[10, 14, 18], [22, 26, 30]]) assert sd[0, 1:2, :].tomatrix() == Matrix([[14, 15, 16, 17]]) assert sd[0, 1:3, :].tomatrix() == Matrix([[14, 15, 16, 17], [18, 19, 20, 21]]) diff --git a/sympy/tensor/array/tests/test_mutable_ndim_array.py b/sympy/tensor/array/tests/test_mutable_ndim_array.py index 528b97cf83c0..3f652f0acb6f 100644 --- a/sympy/tensor/array/tests/test_mutable_ndim_array.py +++ b/sympy/tensor/array/tests/test_mutable_ndim_array.py @@ -104,10 +104,8 @@ def test_reshape(): def test_iterator(): array = MutableDenseNDimArray(range(4), (2, 2)) - j = 0 - for i in array: - assert i == j - j += 1 + array[0] == MutableDenseNDimArray([0, 1]) + array[1] == MutableDenseNDimArray([2, 3]) array = array.reshape(4) j = 0 @@ -139,10 +137,10 @@ def test_sparse(): # dictionary where all data is, only non-zero entries are actually stored: assert len(sparse_array._sparse_array) == 1 - assert list(sparse_array) == [0, 0, 0, 1] + assert sparse_array.tolist() == [[0, 0], [0, 1]] - for i, j in zip(sparse_array, [0, 0, 0, 1]): - assert i == j + for i, j in zip(sparse_array, [[0, 0], [0, 1]]): + assert i == MutableSparseNDimArray(j) sparse_array[0, 0] = 123 assert len(sparse_array._sparse_array) == 2 @@ -186,14 +184,14 @@ def test_calculation(): c = a + b for i in c: - assert i == 10 + assert i == MutableDenseNDimArray([10, 10, 10]) assert c == MutableDenseNDimArray([10]*9, (3, 3)) assert c == MutableSparseNDimArray([10]*9, (3, 3)) c = b - a for i in c: - assert i == 8 + assert i == MutableSparseNDimArray([8, 8, 8]) assert c == MutableDenseNDimArray([8]*9, (3, 3)) assert c == MutableSparseNDimArray([8]*9, (3, 3)) @@ -329,7 +327,7 @@ def test_higher_dimenions(): def test_slices(): md = MutableDenseNDimArray(range(10, 34), (2, 3, 4)) - assert md[:] == md._array + assert md[:] == MutableDenseNDimArray(range(10, 34), (2, 3, 4)) assert md[:, :, 0].tomatrix() == Matrix([[10, 14, 18], [22, 26, 30]]) assert md[0, 1:2, :].tomatrix() == Matrix([[14, 15, 16, 17]]) assert md[0, 1:3, :].tomatrix() == Matrix([[14, 15, 16, 17], [18, 19, 20, 21]]) @@ -338,8 +336,7 @@ def test_slices(): sd = MutableSparseNDimArray(range(10, 34), (2, 3, 4)) assert sd == MutableSparseNDimArray(md) - assert sd[:] == md._array - assert sd[:] == list(sd) + assert sd[:] == MutableSparseNDimArray(range(10, 34), (2, 3, 4)) assert sd[:, :, 0].tomatrix() == Matrix([[10, 14, 18], [22, 26, 30]]) assert sd[0, 1:2, :].tomatrix() == Matrix([[14, 15, 16, 17]]) assert sd[0, 1:3, :].tomatrix() == Matrix([[14, 15, 16, 17], [18, 19, 20, 21]]) diff --git a/sympy/tensor/tests/test_tensor.py b/sympy/tensor/tests/test_tensor.py index 02818166576e..6c413511f993 100644 --- a/sympy/tensor/tests/test_tensor.py +++ b/sympy/tensor/tests/test_tensor.py @@ -1277,21 +1277,23 @@ def test_valued_tensor_iter(): (A, B, AB, BA, C, Lorentz, E, px, py, pz, LorentzD, mu0, mu1, mu2, ndm, n0, n1, n2, NA, NB, NC, minkowski, ba_matrix, ndm_matrix, i0, i1, i2, i3, i4) = _get_valued_base_test_variables() + list_BA = [Array([1, 2, 3, 4]), Array([5, 6, 7, 8]), Array([9, 0, -1, -2]), Array([-3, -4, -5, -6])] # iteration on VTensorHead assert list(A) == [E, px, py, pz] - assert list(ba_matrix) == list(BA) + assert list(ba_matrix) == [1, 2, 3, 4, 5, 6, 7, 8, 9, 0, -1, -2, -3, -4, -5, -6] + assert list(BA) == list_BA # iteration on VTensMul assert list(A(i1)) == [E, px, py, pz] - assert list(BA(i1, i2)) == list(ba_matrix) - assert list(3 * BA(i1, i2)) == [3 * i for i in list(ba_matrix)] - assert list(-5 * BA(i1, i2)) == [-5 * i for i in list(ba_matrix)] + assert list(BA(i1, i2)) == list_BA + assert list(3 * BA(i1, i2)) == [3 * i for i in list_BA] + assert list(-5 * BA(i1, i2)) == [-5 * i for i in list_BA] # iteration on VTensAdd # A(i1) + A(i1) assert list(A(i1) + A(i1)) == [2*E, 2*px, 2*py, 2*pz] assert BA(i1, i2) - BA(i1, i2) == 0 - assert list(BA(i1, i2) - 2 * BA(i1, i2)) == [-i for i in list(ba_matrix)] + assert list(BA(i1, i2) - 2 * BA(i1, i2)) == [-i for i in list_BA] @filter_warnings_decorator

[ { "components": [ { "doc": "Flatten an iterable object to a list in a lazy-evaluation way.\n\nNotes\n=====\n\nThis class is an iterator with which the memory cost can be economised.\nOptimisation has been considered to ameliorate the performance for some\nspecific data types like DenseNDimArray an...

[ "test_sympy__tensor__array__arrayop__Flatten", "test_tensorproduct", "test_tensorcontraction", "test_derivative_by_array", "test_issue_emerged_while_discussing_10972", "test_array_permutedims", "test_sparse", "test_calculation", "test_slices", "test_valued_tensor_iter" ]

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> New __iter__ for Array module  #### References to other Issues or PRs  #### Brief description of what is fixed or changed The array iteration is modified to have a new behavior: Before: ```python >>> a = Array([[1, 2], [3, 4]]) >>> for i in a: ... print(i) ... 1 2 3 4 ``` Now: ```python >>> a = Array([[1, 2], [3, 4]]) >>> for i in a: ... print(i) ... [1, 2] [3, 4] ``` Besides, the iteration over each item is moved to a new object named `nditer` : ```python >>> from sympy.tensor.array.nditer import nditer >>> for i in nditer(a): ... print(i) ... 1 2 3 2 3 4 ``` #### Other comments #### Release Notes   * tensor * Modified __iter__ function and added new class named nditer  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/tensor/array/arrayop.py] (definition of Flatten:) class Flatten(Basic): """Flatten an iterable object to a list in a lazy-evaluation way. Notes ===== This class is an iterator with which the memory cost can be economised. Optimisation has been considered to ameliorate the performance for some specific data types like DenseNDimArray and SparseNDimArray. Examples ======== >>> from sympy.tensor.array.arrayop import Flatten >>> from sympy.tensor.array import Array >>> A = Array(range(6)).reshape(2, 3) >>> Flatten(A) Flatten([[0, 1, 2], [3, 4, 5]]) >>> [i for i in Flatten(A)] [0, 1, 2, 3, 4, 5]""" (definition of Flatten.__init__:) def __init__(self, iterable): (definition of Flatten.__iter__:) def __iter__(self): (definition of Flatten.__next__:) def __next__(self): (definition of Flatten.next:) def next(self): [end of new definitions in sympy/tensor/array/arrayop.py] [start of new definitions in sympy/tensor/array/ndim_array.py] (definition of NDimArray.__iter__:) def __iter__(self): (definition of NDimArray.__iter__.iterator:) def iterator(): [end of new definitions in sympy/tensor/array/ndim_array.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-17306

17,306

sympy/sympy

1.5

d3c1050bae5b6caeeacd03efbe25d3a57ff371a3

2019-07-31T14:29:29Z

diff --git a/sympy/stats/__init__.py b/sympy/stats/__init__.py index 0527237d119a..fbda90016983 100644 --- a/sympy/stats/__init__.py +++ b/sympy/stats/__init__.py @@ -100,6 +100,7 @@ GaussianUnitaryEnsemble, GaussianOrthogonalEnsemble, GaussianSymplecticEnsemble, + JointEigenDistribution, joint_eigen_distribution, level_spacing_distribution ) diff --git a/sympy/stats/random_matrix_models.py b/sympy/stats/random_matrix_models.py index 277e20eecf47..27d3e9c66d17 100644 --- a/sympy/stats/random_matrix_models.py +++ b/sympy/stats/random_matrix_models.py @@ -1,10 +1,12 @@ from __future__ import print_function, division from sympy import (Basic, exp, pi, Lambda, Trace, S, MatrixSymbol, Integral, - gamma, Product, Dummy, Sum, Abs, IndexedBase) + gamma, Product, Dummy, Sum, Abs, IndexedBase, Matrix) from sympy.core.sympify import _sympify from sympy.multipledispatch import dispatch -from sympy.stats.rv import _symbol_converter, Density, RandomMatrixSymbol +from sympy.stats.rv import (_symbol_converter, Density, RandomMatrixSymbol, + RandomSymbol) +from sympy.stats.joint_rv_types import JointDistributionHandmade from sympy.stats.random_matrix import RandomMatrixPSpace from sympy.tensor.array import ArrayComprehension @@ -14,6 +16,7 @@ 'GaussianOrthogonalEnsemble', 'GaussianSymplecticEnsemble', 'joint_eigen_distribution', + 'JointEigenDistribution', 'level_spacing_distribution' ] @@ -184,7 +187,6 @@ def level_spacing_distribution(self): f = ((S(2)**18)/((S(3)**6)*(pi**3)))*(s**4)*exp((-64/(9*pi))*s**2) return Lambda(s, f) -@dispatch(RandomMatrixSymbol) def joint_eigen_distribution(mat): """ For obtaining joint probability distribution @@ -207,11 +209,47 @@ def joint_eigen_distribution(mat): >>> from sympy.stats import GaussianUnitaryEnsemble as GUE >>> from sympy.stats import joint_eigen_distribution >>> U = GUE('U', 2) - >>> joint_eigen_dsitribution(U) + >>> joint_eigen_distribution(U) Lambda((l[1], l[2]), exp(-l[1]**2 - l[2]**2)*Product(Abs(l[_i] - l[_j])**2, (_j, _i + 1, 2), (_i, 1, 1))/pi) """ + if not isinstance(mat, RandomMatrixSymbol): + raise ValueError("%s is not of type, RandomMatrixSymbol."%(mat)) return mat.pspace.model.joint_eigen_distribution() +def JointEigenDistribution(mat): + """ + Creates joint distribution of eigen values of matrices with random + expressions. + + Parameters + ========== + + mat: Matrix + The matrix under consideration + + Returns + ======= + + JointDistributionHandmade + + Examples + ======== + + >>> from sympy.stats import Normal, JointEigenDistribution + >>> from sympy import Matrix + >>> A = [[Normal('A00', 0, 1), Normal('A01', 0, 1)], + ... [Normal('A10', 0, 1), Normal('A11', 0, 1)]] + >>> JointEigenDistribution(Matrix(A)) + JointDistributionHandmade(-sqrt(A00**2 - 2*A00*A11 + 4*A01*A10 + A11**2)/2 + + A00/2 + A11/2, sqrt(A00**2 - 2*A00*A11 + 4*A01*A10 + A11**2)/2 + A00/2 + A11/2) + + """ + eigenvals = mat.eigenvals(multiple=True) + if any(not eigenval.has(RandomSymbol) for eigenval in set(eigenvals)): + raise ValueError("Eigen values don't have any random expression, " + "joint distribution cannot be generated.") + return JointDistributionHandmade(*eigenvals) + def level_spacing_distribution(mat): """ For obtaining distribution of level spacings.

diff --git a/sympy/stats/tests/test_random_matrix.py b/sympy/stats/tests/test_random_matrix.py index 2984692fa735..8402e45a2bb0 100644 --- a/sympy/stats/tests/test_random_matrix.py +++ b/sympy/stats/tests/test_random_matrix.py @@ -1,10 +1,13 @@ from sympy import (sqrt, exp, Trace, pi, S, Integral, MatrixSymbol, Lambda, - Dummy, Product, Sum, Abs, IndexedBase) + Dummy, Product, Sum, Abs, IndexedBase, Matrix) from sympy.stats import (GaussianUnitaryEnsemble as GUE, density, GaussianOrthogonalEnsemble as GOE, GaussianSymplecticEnsemble as GSE, joint_eigen_distribution, - level_spacing_distribution) + JointEigenDistribution, + level_spacing_distribution, + Normal, Beta) +from sympy.stats.joint_rv import JointDistributionHandmade from sympy.stats.rv import RandomMatrixSymbol, Density from sympy.stats.random_matrix_models import GaussianEnsemble from sympy.utilities.pytest import raises @@ -58,3 +61,11 @@ def test_GaussianSymplecticEnsemble(): Product(Abs(l[i] - l[j])**4, (j, i + 1, 3), (i, 1, 2))/(5*pi**(S(3)/2)))) s = Dummy('s') assert level_spacing_distribution(G).dummy_eq(Lambda(s, S(262144)*s**4*exp(-64*s**2/(9*pi))/(729*pi**3))) + +def test_JointEigenDistribution(): + A = Matrix([[Normal('A00', 0, 1), Normal('A01', 1, 1)], + [Beta('A10', 1, 1), Beta('A11', 1, 1)]]) + JointEigenDistribution(A) == \ + JointDistributionHandmade(-sqrt(A[0, 0]**2 - 2*A[0, 0]*A[1, 1] + 4*A[0, 1]*A[1, 0] + A[1, 1]**2)/2 + + A[0, 0]/2 + A[1, 1]/2, sqrt(A[0, 0]**2 - 2*A[0, 0]*A[1, 1] + 4*A[0, 1]*A[1, 0] + A[1, 1]**2)/2 + A[0, 0]/2 + A[1, 1]/2) + raises(ValueError, lambda: JointEigenDistribution(Matrix([[1, 0], [2, 1]])))

[ { "components": [ { "doc": "Creates joint distribution of eigen values of matrices with random\nexpressions.\n\nParameters\n==========\n\nmat: Matrix\n The matrix under consideration\n\nReturns\n=======\n\nJointDistributionHandmade\n\nExamples\n========\n\n>>> from sympy.stats import Normal, Jo...

[ "test_GaussianEnsemble", "test_GaussianUnitaryEnsemble", "test_GaussianOrthogonalEnsemble", "test_GaussianSymplecticEnsemble" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Matrices with random expressions  #### References to other Issues or PRs  #### Brief description of what is fixed or changed N/A #### Other comments ping @Upabjojr @sidhantnagpal #### Release Notes   * stats * Matrices with random expressions have been added in `sympy.stats`.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/random_matrix_models.py] (definition of JointEigenDistribution:) def JointEigenDistribution(mat): """Creates joint distribution of eigen values of matrices with random expressions. Parameters ========== mat: Matrix The matrix under consideration Returns ======= JointDistributionHandmade Examples ======== >>> from sympy.stats import Normal, JointEigenDistribution >>> from sympy import Matrix >>> A = [[Normal('A00', 0, 1), Normal('A01', 0, 1)], ... [Normal('A10', 0, 1), Normal('A11', 0, 1)]] >>> JointEigenDistribution(Matrix(A)) JointDistributionHandmade(-sqrt(A00**2 - 2*A00*A11 + 4*A01*A10 + A11**2)/2 + A00/2 + A11/2, sqrt(A00**2 - 2*A00*A11 + 4*A01*A10 + A11**2)/2 + A00/2 + A11/2)""" [end of new definitions in sympy/stats/random_matrix_models.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-17304

17,304

sympy/sympy

1.5

1b99ff5cc724f195265ec93f7d56b782c82dcb23

2019-07-31T14:17:59Z

diff --git a/sympy/stats/__init__.py b/sympy/stats/__init__.py index fbda90016983..f1ca9b8720f6 100644 --- a/sympy/stats/__init__.py +++ b/sympy/stats/__init__.py @@ -96,6 +96,10 @@ from . import random_matrix_models from .random_matrix_models import ( + CircularEnsemble, + CircularUnitaryEnsemble, + CircularOrthogonalEnsemble, + CircularSymplecticEnsemble, GaussianEnsemble, GaussianUnitaryEnsemble, GaussianOrthogonalEnsemble, diff --git a/sympy/stats/random_matrix_models.py b/sympy/stats/random_matrix_models.py index 27d3e9c66d17..e86c969eb61d 100644 --- a/sympy/stats/random_matrix_models.py +++ b/sympy/stats/random_matrix_models.py @@ -1,9 +1,8 @@ from __future__ import print_function, division from sympy import (Basic, exp, pi, Lambda, Trace, S, MatrixSymbol, Integral, - gamma, Product, Dummy, Sum, Abs, IndexedBase, Matrix) + gamma, Product, Dummy, Sum, Abs, IndexedBase, Matrix, I) from sympy.core.sympify import _sympify -from sympy.multipledispatch import dispatch from sympy.stats.rv import (_symbol_converter, Density, RandomMatrixSymbol, RandomSymbol) from sympy.stats.joint_rv_types import JointDistributionHandmade @@ -11,6 +10,10 @@ from sympy.tensor.array import ArrayComprehension __all__ = [ + 'CircularEnsemble', + 'CircularUnitaryEnsemble', + 'CircularOrthogonalEnsemble', + 'CircularSymplecticEnsemble', 'GaussianEnsemble', 'GaussianUnitaryEnsemble', 'GaussianOrthogonalEnsemble', @@ -22,24 +25,11 @@ class RandomMatrixEnsemble(Basic): """ - Abstract class for random matrix ensembles. - It acts as an umbrella for all the ensembles + Base class for random matrix ensembles. + It acts as an umbrella and contains + the methods common to all the ensembles defined in sympy.stats.random_matrix_models. """ - pass - -class GaussianEnsemble(RandomMatrixEnsemble): - """ - Abstract class for Gaussian ensembles. - Contains the properties common to all the - gaussian ensembles. - - References - ========== - - .. [1] https://en.wikipedia.org/wiki/Random_matrix#Gaussian_ensembles - .. [2] https://arxiv.org/pdf/1712.07903.pdf - """ def __new__(cls, sym, dim=None): sym, dim = _symbol_converter(sym), _sympify(dim) if dim.is_integer == False: @@ -55,6 +45,18 @@ def __new__(cls, sym, dim=None): def density(self, expr): return Density(expr) +class GaussianEnsemble(RandomMatrixEnsemble): + """ + Abstract class for Gaussian ensembles. + Contains the properties common to all the + gaussian ensembles. + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Random_matrix#Gaussian_ensembles + .. [2] https://arxiv.org/pdf/1712.07903.pdf + """ def _compute_normalization_constant(self, beta, n): """ Helper function for computing normalization @@ -74,7 +76,7 @@ def _compute_normalization_constant(self, beta, n): term3 = (2*pi)**(n/2) return term1 * term2 * term3 - def _compute_joint_eigen_dsitribution(self, beta): + def _compute_joint_eigen_distribution(self, beta): """ Helper function for computing the joint probability distribution of eigen values @@ -116,7 +118,7 @@ def density(self, expr): return Lambda(H, exp(-S(n)/2 * Trace(H**2))/ZGUE) def joint_eigen_distribution(self): - return self._compute_joint_eigen_dsitribution(2) + return self._compute_joint_eigen_distribution(S(2)) def level_spacing_distribution(self): s = Dummy('s') @@ -148,7 +150,7 @@ def density(self, expr): return Lambda(H, exp(-S(n)/4 * Trace(H**2))/ZGOE) def joint_eigen_distribution(self): - return self._compute_joint_eigen_dsitribution(1) + return self._compute_joint_eigen_distribution(S(1)) def level_spacing_distribution(self): s = Dummy('s') @@ -180,13 +182,117 @@ def density(self, expr): return Lambda(H, exp(-S(n) * Trace(H**2))/ZGSE) def joint_eigen_distribution(self): - return self._compute_joint_eigen_dsitribution(4) + return self._compute_joint_eigen_distribution(S(4)) def level_spacing_distribution(self): s = Dummy('s') f = ((S(2)**18)/((S(3)**6)*(pi**3)))*(s**4)*exp((-64/(9*pi))*s**2) return Lambda(s, f) +class CircularEnsemble(RandomMatrixEnsemble): + """ + Abstract class for Circular ensembles. + Contains the properties and methods + common to all the circular ensembles. + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Circular_ensemble + """ + def density(self, expr): + # TODO : Add support for Lie groups(as extensions of sympy.diffgeom) + # and define measures on them + raise NotImplementedError("Support for Haar measure hasn't been " + "implemented yet, therefore the density of " + "%s cannot be computed."%(self)) + + def _compute_joint_eigen_distribution(self, beta): + """ + Helper function to compute the joint distribution of phases + of the complex eigen values of matrices belonging to any + circular ensembles. + """ + n = self.dimension + Zbn = ((2*pi)**n)*(gamma(beta*n/2 + 1)/S((gamma(beta/2 + 1)))**n) + t = IndexedBase('t') + i, j, k = (Dummy('i', integer=True), Dummy('j', integer=True), + Dummy('k', integer=True)) + syms = ArrayComprehension(t[i], (i, 1, n)).doit() + f = Product(Product(Abs(exp(I*t[k]) - exp(I*t[j]))**beta, (j, k + 1, n)).doit(), + (k, 1, n - 1)).doit() + return Lambda(syms, f/Zbn) + +class CircularUnitaryEnsemble(CircularEnsemble): + """ + Represents Cicular Unitary Ensembles. + + Examples + ======== + + >>> from sympy.stats import CircularUnitaryEnsemble as CUE, density + >>> from sympy.stats import joint_eigen_distribution + >>> C = CUE('U', 1) + >>> joint_eigen_distribution(C) + Lambda(t[1], Product(Abs(exp(I*t[_j]) - exp(I*t[_k]))**2, (_j, _k + 1, 1), (_k, 1, 0))/(2*pi)) + + Note + ==== + + As can be seen above in the example, density of CiruclarUnitaryEnsemble + is not evaluated becuase the exact definition is based on haar measure of + unitary group which is not unique. + """ + def joint_eigen_distribution(self): + return self._compute_joint_eigen_distribution(S(2)) + +class CircularOrthogonalEnsemble(CircularEnsemble): + """ + Represents Cicular Orthogonal Ensembles. + + Examples + ======== + + >>> from sympy.stats import CircularOrthogonalEnsemble as COE, density + >>> from sympy.stats import joint_eigen_distribution + >>> C = COE('O', 1) + >>> joint_eigen_distribution(C) + Lambda(t[1], Product(Abs(exp(I*t[_j]) - exp(I*t[_k])), (_j, _k + 1, 1), (_k, 1, 0))/(2*pi)) + + Note + ==== + + As can be seen above in the example, density of CiruclarOrthogonalEnsemble + is not evaluated becuase the exact definition is based on haar measure of + unitary group which is not unique. + """ + def joint_eigen_distribution(self): + return self._compute_joint_eigen_distribution(S(1)) + +class CircularSymplecticEnsemble(CircularEnsemble): + """ + Represents Cicular Symplectic Ensembles. + + Examples + ======== + + >>> from sympy.stats import CircularSymplecticEnsemble as CSE, density + >>> from sympy.stats import joint_eigen_distribution + >>> C = CSE('S', 1) + >>> joint_eigen_distribution(C) + Lambda(t[1], Product(Abs(exp(I*t[_j]) - exp(I*t[_k]))**4, (_j, _k + 1, 1), (_k, 1, 0))/(2*pi)) + + Note + ==== + + As can be seen above in the example, density of CiruclarSymplecticEnsemble + is not evaluated becuase the exact definition is based on haar measure of + unitary group which is not unique. + """ + + def joint_eigen_distribution(self): + return self._compute_joint_eigen_distribution(S(4)) + def joint_eigen_distribution(mat): """ For obtaining joint probability distribution

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index bd8178144048..3d3401813579 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1621,11 +1621,11 @@ def test_sympy__stats__stochastic_process_types__ContinuousMarkovChain(): def test_sympy__stats__random_matrix__RandomMatrixPSpace(): from sympy.stats.random_matrix import RandomMatrixPSpace from sympy.stats.random_matrix_models import RandomMatrixEnsemble - assert _test_args(RandomMatrixPSpace('P', RandomMatrixEnsemble())) + assert _test_args(RandomMatrixPSpace('P', RandomMatrixEnsemble('R', 3))) def test_sympy__stats__random_matrix_models__RandomMatrixEnsemble(): from sympy.stats.random_matrix_models import RandomMatrixEnsemble - assert _test_args(RandomMatrixEnsemble()) + assert _test_args(RandomMatrixEnsemble('R', 3)) def test_sympy__stats__random_matrix_models__GaussianEnsemble(): from sympy.stats.random_matrix_models import GaussianEnsemble @@ -1643,6 +1643,22 @@ def test_sympy__stats__random_matrix_models__GaussianSymplecticEnsemble(): from sympy.stats import GaussianSymplecticEnsemble assert _test_args(GaussianSymplecticEnsemble('U', 3)) +def test_sympy__stats__random_matrix_models__CircularEnsemble(): + from sympy.stats import CircularEnsemble + assert _test_args(CircularEnsemble('C', 3)) + +def test_sympy__stats__random_matrix_models__CircularUnitaryEnsemble(): + from sympy.stats import CircularUnitaryEnsemble + assert _test_args(CircularUnitaryEnsemble('U', 3)) + +def test_sympy__stats__random_matrix_models__CircularOrthogonalEnsemble(): + from sympy.stats import CircularOrthogonalEnsemble + assert _test_args(CircularOrthogonalEnsemble('O', 3)) + +def test_sympy__stats__random_matrix_models__CircularSymplecticEnsemble(): + from sympy.stats import CircularSymplecticEnsemble + assert _test_args(CircularSymplecticEnsemble('S', 3)) + def test_sympy__core__symbol__Dummy(): from sympy.core.symbol import Dummy assert _test_args(Dummy('t')) diff --git a/sympy/stats/tests/test_random_matrix.py b/sympy/stats/tests/test_random_matrix.py index 8402e45a2bb0..ef7f502c745f 100644 --- a/sympy/stats/tests/test_random_matrix.py +++ b/sympy/stats/tests/test_random_matrix.py @@ -1,9 +1,13 @@ from sympy import (sqrt, exp, Trace, pi, S, Integral, MatrixSymbol, Lambda, - Dummy, Product, Sum, Abs, IndexedBase, Matrix) + Dummy, Product, Sum, Abs, IndexedBase, Matrix, I) from sympy.stats import (GaussianUnitaryEnsemble as GUE, density, GaussianOrthogonalEnsemble as GOE, GaussianSymplecticEnsemble as GSE, joint_eigen_distribution, + level_spacing_distribution, + CircularUnitaryEnsemble as CUE, + CircularOrthogonalEnsemble as COE, + CircularSymplecticEnsemble as CSE, JointEigenDistribution, level_spacing_distribution, Normal, Beta) @@ -62,6 +66,39 @@ def test_GaussianSymplecticEnsemble(): s = Dummy('s') assert level_spacing_distribution(G).dummy_eq(Lambda(s, S(262144)*s**4*exp(-64*s**2/(9*pi))/(729*pi**3))) +def test_CircularUnitaryEnsemble(): + CU = CUE('U', 3) + j, k = (Dummy('j', integer=True, positive=True), + Dummy('k', integer=True, positive=True)) + t = IndexedBase('t') + assert joint_eigen_distribution(CU).dummy_eq( + Lambda((t[1], t[2], t[3]), + Product(Abs(exp(I*t[j]) - exp(I*t[k]))**2, + (j, k + 1, 3), (k, 1, 2))/(48*pi**3)) + ) + +def test_CircularOrthogonalEnsemble(): + CO = COE('U', 3) + j, k = (Dummy('j', integer=True, positive=True), + Dummy('k', integer=True, positive=True)) + t = IndexedBase('t') + assert joint_eigen_distribution(CO).dummy_eq( + Lambda((t[1], t[2], t[3]), + Product(Abs(exp(I*t[j]) - exp(I*t[k])), + (j, k + 1, 3), (k, 1, 2))/(48*pi**2)) + ) + +def test_CircularSymplecticEnsemble(): + CS = CSE('U', 3) + j, k = (Dummy('j', integer=True, positive=True), + Dummy('k', integer=True, positive=True)) + t = IndexedBase('t') + assert joint_eigen_distribution(CS).dummy_eq( + Lambda((t[1], t[2], t[3]), + Product(Abs(exp(I*t[j]) - exp(I*t[k]))**4, + (j, k + 1, 3), (k, 1, 2))/(720*pi**3)) + ) + def test_JointEigenDistribution(): A = Matrix([[Normal('A00', 0, 1), Normal('A01', 1, 1)], [Beta('A10', 1, 1), Beta('A11', 1, 1)]])

[ { "components": [ { "doc": "", "lines": [ 33, 40 ], "name": "RandomMatrixEnsemble.__new__", "signature": "def __new__(cls, sym, dim=None):", "type": "function" }, { "doc": "", "lines": [ 45, ...

[ "test_sympy__stats__random_matrix_models__RandomMatrixEnsemble", "test_sympy__stats__random_matrix_models__CircularEnsemble", "test_sympy__stats__random_matrix_models__CircularUnitaryEnsemble", "test_sympy__stats__random_matrix_models__CircularOrthogonalEnsemble", "test_sympy__stats__random_matrix_models__C...

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added circular ensembles  #### References to other Issues or PRs  #### Brief description of what is fixed or changed Circular ensembles have been added. #### Other comments More features will be added, if possible. @Upabjojr @sidhantnagpal I am facing a problem(well the last option will be to keep it unevaluated) in exactly defining the density, since it is based on Haar measure which is not unique. Please let me know of any thing available in the literature so that I can do some improvements. I am also right now doing some searching on Google. #### Release Notes   * stats * Circular ensembles have been added in `sympy.stats`.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/random_matrix_models.py] (definition of RandomMatrixEnsemble.__new__:) def __new__(cls, sym, dim=None): (definition of RandomMatrixEnsemble.density:) def density(self, expr): (definition of GaussianEnsemble._compute_joint_eigen_distribution:) def _compute_joint_eigen_distribution(self, beta): """Helper function for computing the joint probability distribution of eigen values of the random matrix.""" (definition of CircularEnsemble:) class CircularEnsemble(RandomMatrixEnsemble): """Abstract class for Circular ensembles. Contains the properties and methods common to all the circular ensembles. References ========== .. [1] https://en.wikipedia.org/wiki/Circular_ensemble""" (definition of CircularEnsemble.density:) def density(self, expr): (definition of CircularEnsemble._compute_joint_eigen_distribution:) def _compute_joint_eigen_distribution(self, beta): """Helper function to compute the joint distribution of phases of the complex eigen values of matrices belonging to any circular ensembles.""" (definition of CircularUnitaryEnsemble:) class CircularUnitaryEnsemble(CircularEnsemble): """Represents Cicular Unitary Ensembles. Examples ======== >>> from sympy.stats import CircularUnitaryEnsemble as CUE, density >>> from sympy.stats import joint_eigen_distribution >>> C = CUE('U', 1) >>> joint_eigen_distribution(C) Lambda(t[1], Product(Abs(exp(I*t[_j]) - exp(I*t[_k]))**2, (_j, _k + 1, 1), (_k, 1, 0))/(2*pi)) Note ==== As can be seen above in the example, density of CiruclarUnitaryEnsemble is not evaluated becuase the exact definition is based on haar measure of unitary group which is not unique.""" (definition of CircularUnitaryEnsemble.joint_eigen_distribution:) def joint_eigen_distribution(self): (definition of CircularOrthogonalEnsemble:) class CircularOrthogonalEnsemble(CircularEnsemble): """Represents Cicular Orthogonal Ensembles. Examples ======== >>> from sympy.stats import CircularOrthogonalEnsemble as COE, density >>> from sympy.stats import joint_eigen_distribution >>> C = COE('O', 1) >>> joint_eigen_distribution(C) Lambda(t[1], Product(Abs(exp(I*t[_j]) - exp(I*t[_k])), (_j, _k + 1, 1), (_k, 1, 0))/(2*pi)) Note ==== As can be seen above in the example, density of CiruclarOrthogonalEnsemble is not evaluated becuase the exact definition is based on haar measure of unitary group which is not unique.""" (definition of CircularOrthogonalEnsemble.joint_eigen_distribution:) def joint_eigen_distribution(self): (definition of CircularSymplecticEnsemble:) class CircularSymplecticEnsemble(CircularEnsemble): """Represents Cicular Symplectic Ensembles. Examples ======== >>> from sympy.stats import CircularSymplecticEnsemble as CSE, density >>> from sympy.stats import joint_eigen_distribution >>> C = CSE('S', 1) >>> joint_eigen_distribution(C) Lambda(t[1], Product(Abs(exp(I*t[_j]) - exp(I*t[_k]))**4, (_j, _k + 1, 1), (_k, 1, 0))/(2*pi)) Note ==== As can be seen above in the example, density of CiruclarSymplecticEnsemble is not evaluated becuase the exact definition is based on haar measure of unitary group which is not unique.""" (definition of CircularSymplecticEnsemble.joint_eigen_distribution:) def joint_eigen_distribution(self): [end of new definitions in sympy/stats/random_matrix_models.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

joke2k__faker-984

984

joke2k/faker

null

e93e4d1e5bfdb1cfa08ae5112466494d7ec1718b

2019-07-30T11:01:14Z

diff --git a/faker/providers/geo/pt_PT/__init__.py b/faker/providers/geo/pt_PT/__init__.py new file mode 100644 index 0000000000..7415c5cbfe --- /dev/null +++ b/faker/providers/geo/pt_PT/__init__.py @@ -0,0 +1,30 @@ +# coding=utf-8 + +from __future__ import unicode_literals +from .. import Provider as GeoProvider + + +class Provider(GeoProvider): + + nationalities = ( + "Afegã", "Albanesa", "Arménia", "Angolana", "Argentina", "Austríaca", "Australiana", "Azerbaijã", "Belga", + "Bulgara", "Boliviana", "Brasileira", "Bielorussa", "Canadiana", "Congolesa (República Democrática do Congo)", + "Congolesa (República do Congo)", "Suíça", "Marfinense", "Chilena", "Chinesa", "Colombiana", "Costa-Riquenha", + "Cubana", "Cabo-verdiana", "Cipriota", "Checa", "Alemã", "Dinamarquesa", "Dominicana", "Argelina", + "Equatoriana", "Estónia", "Egípcia", "Espanhola", "Etíope", "Finlândesa", "Francesa", "Grega", + "Guineense (Bissau)", "Croata", "Húngara", "Indonésia", "Irlandesa", "Israelita", "Indiana", "Iraquiana", + "Iraniana", "Islandesa", "Italiana", "Jamaicana", "Japonesa", "Queniana", "Coreana", "Libanesa", "Lituana", + "Luxemburguesa", "Letã", "Marroquina", "Moldava", "Birmanesa", "Maltesa", "Mexicana", "Moçambicana", + "Nigeriana", "Holandesa", "Norueguesa", "Nepalesa", "Neozelandesa", "Peruana", "Filipina", "Paquistanesa", + "Polaca", "Portuguesa", "Paraguaia", "Romena", "Russa", "Ruandesa", "Sudanesa", "Sueca", "Eslovena", "Eslovaca", + "Senegalesa", "Somali", "Santomense", "Salvadorenha", "Tailandesa", "Tunisina", "Turca", "Ucraniana", + "Britânica", "Americana", "Uruguaia", "Venezuelana", "Vietnamita", "Sul-Africana", "Sérvia", "Andorrenha", + "Bósnia", "Camaronesa", "Georgiana", "Ganesa", "Gambiana", "Hondurenha", "Haitiana", "Cazaque", "Libanesa ", + "Monegasca", "Maliana", "Mongol", "Mauritana", "Malaia", "Panamiana", "Saudita", "Singapurense", "Togolesa", + ) + + def nationality(self): + """ + :example 'Portuguesa' + """ + return self.random_element(self.nationalities)

diff --git a/tests/providers/test_geo.py b/tests/providers/test_geo.py index eb4b2fa34f..5b152eda5f 100644 --- a/tests/providers/test_geo.py +++ b/tests/providers/test_geo.py @@ -5,8 +5,10 @@ import re import unittest from decimal import Decimal +from six import string_types from faker import Faker +from faker.providers.geo.pt_PT import Provider as PtPtProvider class TestGlobal(unittest.TestCase): @@ -93,3 +95,14 @@ def test_local_latitude(self): def test_local_longitude(self): local_longitude = self.factory.local_longitude() assert re.match(r"1[1-5]\.\d+", str(local_longitude)) + + +class TestPtPT(unittest.TestCase): + + def setUp(self): + self.factory = Faker('pt_PT') + + def test_nationality(self): + nationality = self.factory.nationality() + assert isinstance(nationality, string_types) + assert nationality in PtPtProvider.nationalities

[ { "components": [ { "doc": "", "lines": [ 7, 30 ], "name": "Provider", "signature": "class Provider(GeoProvider):", "type": "class" }, { "doc": ":example 'Portuguesa'", "lines": [ 26, 30 ...

[ "tests/providers/test_geo.py::TestGlobal::test_local_latlng", "tests/providers/test_geo.py::TestEnUS::test_coordinate", "tests/providers/test_geo.py::TestEnUS::test_coordinate_centered", "tests/providers/test_geo.py::TestEnUS::test_coordinate_rounded", "tests/providers/test_geo.py::TestEnUS::test_latitude",...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added nationalities for locale pt_PT. Tests are also provided ### What does this changes It adds nationalities in portuguese Tests are also provided Brief summary of the changes It adds nationalities in portuguese Tests are also provided ### What was wrong Nothing, it is just missing this piece of data ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/geo/pt_PT/__init__.py] (definition of Provider:) class Provider(GeoProvider): (definition of Provider.nationality:) def nationality(self): """:example 'Portuguesa'""" [end of new definitions in faker/providers/geo/pt_PT/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

6edfdbf6ae90b0153309e3bf066aa3b2d16494a7

sympy__sympy-17266

17,266

sympy/sympy

1.5

2d700c4b3c0871a26741456787b0555eed9d5546

2019-07-26T06:35:30Z

diff --git a/.gitignore b/.gitignore index 2614e1546e15..db4a22815e50 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,8 @@ # track a file that is ignored for some reason, you have to use # "git add -f". See "git help gitignore" for more information. +# Virtualenv +/.venv/ # Regular Python bytecode file *.pyc diff --git a/doc/src/modules/printing.rst b/doc/src/modules/printing.rst index 2adf23a024cb..4729ed9a25b6 100644 --- a/doc/src/modules/printing.rst +++ b/doc/src/modules/printing.rst @@ -301,6 +301,20 @@ Mathematica code printing .. autofunction:: sympy.printing.mathematica.mathematica_code +Maple code printing +------------------- + +.. module:: sympy.printing.maple + +.. autoclass:: sympy.printing.maple.MapleCodePrinter + :members: + + .. autoattribute:: MapleCodePrinter.printmethod + +.. autofunction:: sympy.printing.maple.maple_code + +.. autofunction:: sympy.printing.maple.print_maple_code + Javascript Code printing ------------------------ diff --git a/sympy/printing/__init__.py b/sympy/printing/__init__.py index 2b73f8359d16..39a66b511292 100644 --- a/sympy/printing/__init__.py +++ b/sympy/printing/__init__.py @@ -67,3 +67,6 @@ from .dot import dotprint __all__ += ['dotprint'] + +from .maple import maple_code, print_maple_code +__all__ += ['maple_code', 'print_maple_code'] diff --git a/sympy/printing/maple.py b/sympy/printing/maple.py new file mode 100644 index 000000000000..67c63c0e2527 --- /dev/null +++ b/sympy/printing/maple.py @@ -0,0 +1,318 @@ +""" +Maple code printer + +The MapleCodePrinter converts single sympy expressions into single +Maple expressions, using the functions defined in the Maple objects where possible. + + +FIXME: This module is still under actively developed. Some functions may be not completed. +""" + +from __future__ import print_function, division + +from sympy.codegen.ast import Assignment +from sympy.core import S +from sympy.core.basic import Atom +from sympy.core.numbers import Integer, IntegerConstant +from sympy.core.compatibility import string_types, range +from sympy.printing.codeprinter import CodePrinter +from sympy.printing.precedence import precedence, PRECEDENCE + +import sympy + +_known_func_same_name = [ + 'sin', 'cos', 'tan', 'sec', 'csc', 'cot', 'sinh', 'cosh', 'tanh', 'sech', + 'csch', 'coth', 'exp', 'floor', 'factorial' +] + +known_functions = { + # Sympy -> Maple + 'Abs': 'abs', + 'log': 'ln', + 'asin': 'arcsin', + 'acos': 'arccos', + 'atan': 'arctan', + 'asec': 'arcsec', + 'acsc': 'arccsc', + 'acot': 'arccot', + 'asinh': 'arcsinh', + 'acosh': 'arccosh', + 'atanh': 'arctanh', + 'asech': 'arcsech', + 'acsch': 'arccsch', + 'acoth': 'arccoth', + 'ceiling': 'ceil', + + 'besseli': 'BesselI', + 'besselj': 'BesselJ', + 'besselk': 'BesselK', + 'bessely': 'BesselY', + 'hankelh1': 'HankelH1', + 'hankelh2': 'HankelH2', + 'airyai': 'AiryAi', + 'airybi': 'AiryBi' +} +for _func in _known_func_same_name: + known_functions[_func] = _func + +number_symbols = { + # Sympy -> Maple + S.Pi: 'Pi', + S.Exp1: 'exp(1)', + S.Catalan: 'Catalan', + S.EulerGamma: 'gamma', + S.GoldenRatio: '(1/2 + (1/2)*sqrt(5))' +} + +spec_relational_ops = { + # Sympy -> Maple + '==': '=', + '!=': '<>' +} + +not_supported_symbol = [ + S.ComplexInfinity +] + +class MapleCodePrinter(CodePrinter): + """ + Printer which converts a sympy expression into a maple code. + """ + printmethod = "_maple" + language = "maple" + + _default_settings = { + 'order': None, + 'full_prec': 'auto', + 'human': True, + 'inline': True, + 'allow_unknown_functions': True, + } + + def __init__(self, settings=None): + if settings is None: + settings = dict() + super(MapleCodePrinter, self).__init__(settings) + self.known_functions = dict(known_functions) + userfuncs = settings.get('user_functions', {}) + self.known_functions.update(userfuncs) + + def _get_statement(self, codestring): + return "%s;" % codestring + + def _get_comment(self, text): + return "# {0}".format(text) + + def _declare_number_const(self, name, value): + return "{0} := {1};".format(name, + value.evalf(self._settings['precision'])) + + def _format_code(self, lines): + return lines + + def _print_tuple(self, expr): + return self._print(list(expr)) + + def _print_Tuple(self, expr): + return self._print(list(expr)) + + def _print_Assignment(self, expr): + lhs = self._print(expr.lhs) + rhs = self._print(expr.rhs) + return "{lhs} := {rhs}".format(lhs=lhs, rhs=rhs) + + def _print_Pow(self, expr, **kwargs): + PREC = precedence(expr) + if expr.exp == -1: + return '1/%s' % (self.parenthesize(expr.base, PREC)) + elif expr.exp == 0.5 or expr.exp == S(1) / 2: + return 'sqrt(%s)' % self._print(expr.base) + elif expr.exp == -0.5 or expr.exp == -S(1) / 2: + return '1/sqrt(%s)' % self._print(expr.base) + else: + return '{base}^{exp}'.format( + base=self.parenthesize(expr.base, PREC), + exp=self.parenthesize(expr.exp, PREC)) + + def _print_Piecewise(self, expr): + if (expr.args[-1].cond is not True) and (expr.args[-1].cond != S.BooleanTrue): + # We need the last conditional to be a True, otherwise the resulting + # function may not return a result. + raise ValueError("All Piecewise expressions must contain an " + "(expr, True) statement to be used as a default " + "condition. Without one, the generated " + "expression may not evaluate to anything under " + "some condition.") + _coup_list = [ + ("{c}, {e}".format(c=self._print(c), + e=self._print(e)) if c is not True and c is not S.BooleanTrue else "{e}".format( + e=self._print(e))) + for e, c in expr.args] + _inbrace = ', '.join(_coup_list) + return 'piecewise({_inbrace})'.format(_inbrace=_inbrace) + + def _print_Rational(self, expr): + p, q = int(expr.p), int(expr.q) + return "{p}/{q}".format(p=str(p), q=str(q)) + + def _print_Relational(self, expr): + PREC=precedence(expr) + lhs_code = self.parenthesize(expr.lhs, PREC) + rhs_code = self.parenthesize(expr.rhs, PREC) + op = expr.rel_op + if op in spec_relational_ops: + op = spec_relational_ops[op] + return "{lhs} {rel_op} {rhs}".format(lhs=lhs_code, rel_op=op, rhs=rhs_code) + + def _print_NumberSymbol(self, expr): + return number_symbols[expr] + + def _print_NegativeInfinity(self, expr): + return '-infinity' + + def _print_Infinity(self, expr): + return 'infinity' + + def _print_Idx(self, expr): + return self._print(expr.label) + + def _print_BooleanTrue(self, expr): + return "true" + + def _print_BooleanFalse(self, expr): + return "false" + + def _print_bool(self, expr): + return 'true' if expr else 'false' + + def _print_NaN(self, expr): + return 'undefined' + + def _get_matrix(self, expr, sparse=False): + if expr.cols == 0 or expr.rows == 0: + _strM = 'Matrix([], storage = {storage})'.format( + storage='sparse' if sparse else 'rectangular') + else: + _strM = 'Matrix({list}, storage = {storage})'.format( + list=self._print(expr.tolist()), + storage='sparse' if sparse else 'rectangular') + return _strM + + def _print_MatrixElement(self, expr): + return "{parent}[{i_maple}, {j_maple}]".format( + parent=self.parenthesize(expr.parent, PRECEDENCE["Atom"], strict=True), + i_maple=self._print(expr.i + 1), + j_maple=self._print(expr.j + 1)) + + def _print_MatrixBase(self, expr): + return self._get_matrix(expr, sparse=False) + + def _print_SparseMatrix(self, expr): + return self._get_matrix(expr, sparse=True) + + _print_Matrix = \ + _print_DenseMatrix = \ + _print_MutableDenseMatrix = \ + _print_ImmutableMatrix = \ + _print_ImmutableDenseMatrix = \ + _print_MatrixBase + _print_MutableSparseMatrix = \ + _print_ImmutableSparseMatrix = \ + _print_SparseMatrix + + def _print_Identity(self, expr): + if isinstance(expr.rows, Integer) or isinstance(expr.rows, IntegerConstant): + return self._print(sympy.SparseMatrix(expr)) + else: + return "Matrix({var_size}, shape = identity)".format(var_size=self._print(expr.rows)) + + def _print_MatMul(self, expr): + PREC=precedence(expr) + _fact_list = list(expr.args) + _const = None + if not ( + isinstance(_fact_list[0], sympy.MatrixBase) or isinstance( + _fact_list[0], sympy.MatrixExpr) or isinstance( + _fact_list[0], sympy.MatrixSlice) or isinstance( + _fact_list[0], sympy.MatrixSymbol)): + _const, _fact_list = _fact_list[0], _fact_list[1:] + + if _const is None or _const == 1: + return '.'.join(self.parenthesize(_m, PREC) for _m in _fact_list) + else: + return '{c}*{m}'.format(c=_const, m='.'.join(self.parenthesize(_m, PREC) for _m in _fact_list)) + + def _print_MatPow(self, expr): + # This function requires LinearAlgebra Function in Maple + return 'MatrixPower({A}, {n})'.format(A=self._print(expr.base), n=self._print(expr.exp)) + + def _print_HadamardProduct(self, expr): + PREC = precedence(expr) + _fact_list = list(expr.args) + return '*'.join(self.parenthesize(_m, PREC) for _m in _fact_list) + + def _print_Derivative(self, expr): + _f, (_var, _order) = expr.args + + if _order != 1: + _second_arg = '{var}${order}'.format(var=self._print(_var), + order=self._print(_order)) + else: + _second_arg = '{var}'.format(var=self._print(_var)) + return 'diff({func_expr}, {sec_arg})'.format(func_expr=self._print(_f), sec_arg=_second_arg) + + +def maple_code(expr, assign_to=None, **settings): + r"""Converts ``expr`` to a string of Maple code. + + Parameters + ========== + + expr : Expr + A sympy expression to be converted. + assign_to : optional + When given, the argument is used as the name of the variable to which + the expression is assigned. Can be a string, ``Symbol``, + ``MatrixSymbol``, or ``Indexed`` type. This can be helpful for + expressions that generate multi-line statements. + precision : integer, optional + The precision for numbers such as pi [default=16]. + user_functions : dict, optional + A dictionary where keys are ``FunctionClass`` instances and values are + their string representations. Alternatively, the dictionary value can + be a list of tuples i.e. [(argument_test, cfunction_string)]. See + below for examples. + human : bool, optional + If True, the result is a single string that may contain some constant + declarations for the number symbols. If False, the same information is + returned in a tuple of (symbols_to_declare, not_supported_functions, + code_text). [default=True]. + contract: bool, optional + If True, ``Indexed`` instances are assumed to obey tensor contraction + rules and the corresponding nested loops over indices are generated. + Setting contract=False will not generate loops, instead the user is + responsible to provide values for the indices in the code. + [default=True]. + inline: bool, optional + If True, we try to create single-statement code instead of multiple + statements. [default=True]. + + """ + return MapleCodePrinter(settings).doprint(expr, assign_to) + + +def print_maple_code(expr, **settings): + """Prints the Maple representation of the given expression. + + See :func:`maple_code` for the meaning of the optional arguments. + + Examples + ======== + + >>> from sympy.printing.maple import print_maple_code + >>> from sympy import symbols + >>> x, y = symbols('x y') + >>> print_maple_code(x, assign_to=y) + y := x + """ + print(maple_code(expr, **settings))

diff --git a/sympy/printing/tests/test_maple.py b/sympy/printing/tests/test_maple.py new file mode 100644 index 000000000000..70fbcda0c3af --- /dev/null +++ b/sympy/printing/tests/test_maple.py @@ -0,0 +1,384 @@ +from sympy.core import (S, pi, oo, symbols, Function, Rational, Integer, + Tuple, Symbol, Eq, Ne, Le, Lt, Gt, Ge) +from sympy.core import EulerGamma, GoldenRatio, Catalan, Lambda, Mul, Pow +from sympy.functions import Piecewise, sqrt, ceiling, exp, sin, cos +from sympy.utilities.pytest import raises +from sympy.utilities.lambdify import implemented_function +from sympy.matrices import (eye, Matrix, MatrixSymbol, Identity, + HadamardProduct, SparseMatrix) +from sympy.functions.special.bessel import (jn, yn, besselj, bessely, besseli, + besselk, hankel1, hankel2, airyai, + airybi, airyaiprime, airybiprime) +from sympy.utilities.pytest import XFAIL + +from sympy import maple_code + +x, y, z = symbols('x,y,z') + + +def test_Integer(): + assert maple_code(Integer(67)) == "67" + assert maple_code(Integer(-1)) == "-1" + + +def test_Rational(): + assert maple_code(Rational(3, 7)) == "3/7" + assert maple_code(Rational(18, 9)) == "2" + assert maple_code(Rational(3, -7)) == "-3/7" + assert maple_code(Rational(-3, -7)) == "3/7" + assert maple_code(x + Rational(3, 7)) == "x + 3/7" + assert maple_code(Rational(3, 7) * x) == '(3/7)*x' + + +def test_Relational(): + assert maple_code(Eq(x, y)) == "x = y" + assert maple_code(Ne(x, y)) == "x <> y" + assert maple_code(Le(x, y)) == "x <= y" + assert maple_code(Lt(x, y)) == "x < y" + assert maple_code(Gt(x, y)) == "x > y" + assert maple_code(Ge(x, y)) == "x >= y" + + +def test_Function(): + assert maple_code(sin(x) ** cos(x)) == "sin(x)^cos(x)" + assert maple_code(abs(x)) == "abs(x)" + assert maple_code(ceiling(x)) == "ceil(x)" + + +def test_Pow(): + assert maple_code(x ** 3) == "x^3" + assert maple_code(x ** (y ** 3)) == "x^(y^3)" + + assert maple_code((x ** 3) ** y) == "(x^3)^y" + assert maple_code(x ** Rational(2, 3)) == 'x^(2/3)' + + g = implemented_function('g', Lambda(x, 2 * x)) + assert maple_code(1 / (g(x) * 3.5) ** (x - y ** x) / (x ** 2 + y)) == \ + "(3.5*2*x)^(-x + y^x)/(x^2 + y)" + # For issue 14160 + assert maple_code(Mul(-2, x, Pow(Mul(y, y, evaluate=False), -1, evaluate=False), + evaluate=False)) == '-2*x/(y*y)' + + +def test_basic_ops(): + assert maple_code(x * y) == "x*y" + assert maple_code(x + y) == "x + y" + assert maple_code(x - y) == "x - y" + assert maple_code(-x) == "-x" + + +def test_1_over_x_and_sqrt(): + # 1.0 and 0.5 would do something different in regular StrPrinter, + # but these are exact in IEEE floating point so no different here. + assert maple_code(1 / x) == '1/x' + assert maple_code(x ** -1) == maple_code(x ** -1.0) == '1/x' + assert maple_code(1 / sqrt(x)) == '1/sqrt(x)' + assert maple_code(x ** -S.Half) == maple_code(x ** -0.5) == '1/sqrt(x)' + assert maple_code(sqrt(x)) == 'sqrt(x)' + assert maple_code(x ** S.Half) == maple_code(x ** 0.5) == 'sqrt(x)' + assert maple_code(1 / pi) == '1/Pi' + assert maple_code(pi ** -1) == maple_code(pi ** -1.0) == '1/Pi' + assert maple_code(pi ** -0.5) == '1/sqrt(Pi)' + + +def test_mix_number_mult_symbols(): + assert maple_code(3 * x) == "3*x" + assert maple_code(pi * x) == "Pi*x" + assert maple_code(3 / x) == "3/x" + assert maple_code(pi / x) == "Pi/x" + assert maple_code(x / 3) == '(1/3)*x' + assert maple_code(x / pi) == "x/Pi" + assert maple_code(x * y) == "x*y" + assert maple_code(3 * x * y) == "3*x*y" + assert maple_code(3 * pi * x * y) == "3*Pi*x*y" + assert maple_code(x / y) == "x/y" + assert maple_code(3 * x / y) == "3*x/y" + assert maple_code(x * y / z) == "x*y/z" + assert maple_code(x / y * z) == "x*z/y" + assert maple_code(1 / x / y) == "1/(x*y)" + assert maple_code(2 * pi * x / y / z) == "2*Pi*x/(y*z)" + assert maple_code(3 * pi / x) == "3*Pi/x" + assert maple_code(S(3) / 5) == "3/5" + assert maple_code(S(3) / 5 * x) == '(3/5)*x' + assert maple_code(x / y / z) == "x/(y*z)" + assert maple_code((x + y) / z) == "(x + y)/z" + assert maple_code((x + y) / (z + x)) == "(x + y)/(x + z)" + assert maple_code((x + y) / EulerGamma) == '(x + y)/gamma' + assert maple_code(x / 3 / pi) == '(1/3)*x/Pi' + assert maple_code(S(3) / 5 * x * y / pi) == '(3/5)*x*y/Pi' + + +def test_mix_number_pow_symbols(): + assert maple_code(pi ** 3) == 'Pi^3' + assert maple_code(x ** 2) == 'x^2' + + assert maple_code(x ** (pi ** 3)) == 'x^(Pi^3)' + assert maple_code(x ** y) == 'x^y' + + assert maple_code(x ** (y ** z)) == 'x^(y^z)' + assert maple_code((x ** y) ** z) == '(x^y)^z' + + +def test_imag(): + I = S('I') + assert maple_code(I) == "I" + assert maple_code(5 * I) == "5*I" + + assert maple_code((S(3) / 2) * I) == "(3/2)*I" + assert maple_code(3 + 4 * I) == "3 + 4*I" + + +def test_constants(): + assert maple_code(pi) == "Pi" + assert maple_code(oo) == "infinity" + assert maple_code(-oo) == "-infinity" + assert maple_code(S.NegativeInfinity) == "-infinity" + assert maple_code(S.NaN) == "undefined" + assert maple_code(S.Exp1) == "exp(1)" + assert maple_code(exp(1)) == "exp(1)" + + +def test_constants_other(): + assert maple_code(2 * GoldenRatio) == '2*(1/2 + (1/2)*sqrt(5))' + assert maple_code(2 * Catalan) == '2*Catalan' + assert maple_code(2 * EulerGamma) == "2*gamma" + + +def test_boolean(): + assert maple_code(x & y) == "x && y" + assert maple_code(x | y) == "x || y" + assert maple_code(~x) == "!x" + assert maple_code(x & y & z) == "x && y && z" + assert maple_code(x | y | z) == "x || y || z" + assert maple_code((x & y) | z) == "z || x && y" + assert maple_code((x | y) & z) == "z && (x || y)" + + +def test_Matrices(): + assert maple_code(Matrix(1, 1, [10])) == \ + 'Matrix([[10]], storage = rectangular)' + + A = Matrix([[1, sin(x / 2), abs(x)], + [0, 1, pi], + [0, exp(1), ceiling(x)]]) + expected = \ + 'Matrix(' \ + '[[1, sin((1/2)*x), abs(x)],' \ + ' [0, 1, Pi],' \ + ' [0, exp(1), ceil(x)]], ' \ + 'storage = rectangular)' + assert maple_code(A) == expected + + # row and columns + assert maple_code(A[:, 0]) == \ + 'Matrix([[1], [0], [0]], storage = rectangular)' + assert maple_code(A[0, :]) == \ + 'Matrix([[1, sin((1/2)*x), abs(x)]], storage = rectangular)' + assert maple_code(Matrix([[x, x - y, -y]])) == \ + 'Matrix([[x, x - y, -y]], storage = rectangular)' + + # empty matrices + assert maple_code(Matrix(0, 0, [])) == \ + 'Matrix([], storage = rectangular)' + assert maple_code(Matrix(0, 3, [])) == \ + 'Matrix([], storage = rectangular)' + +def test_SparseMatrices(): + assert maple_code(SparseMatrix(Identity(2))) == 'Matrix([[1, 0], [0, 1]], storage = sparse)' + + +def test_vector_entries_hadamard(): + # For a row or column, user might to use the other dimension + A = Matrix([[1, sin(2 / x), 3 * pi / x / 5]]) + assert maple_code(A) == \ + 'Matrix([[1, sin(2/x), (3/5)*Pi/x]], storage = rectangular)' + assert maple_code(A.T) == \ + 'Matrix([[1], [sin(2/x)], [(3/5)*Pi/x]], storage = rectangular)' + + +def test_Matrices_entries_not_hadamard(): + A = Matrix([[1, sin(2 / x), 3 * pi / x / 5], [1, 2, x * y]]) + expected = \ + 'Matrix([[1, sin(2/x), (3/5)*Pi/x], [1, 2, x*y]], ' \ + 'storage = rectangular)' + assert maple_code(A) == expected + + +def test_MatrixSymbol(): + n = Symbol('n', integer=True) + A = MatrixSymbol('A', n, n) + B = MatrixSymbol('B', n, n) + assert maple_code(A * B) == "A.B" + assert maple_code(B * A) == "B.A" + assert maple_code(2 * A * B) == "2*A.B" + assert maple_code(B * 2 * A) == "2*B.A" + + assert maple_code( + A * (B + 3 * Identity(n))) == "A.(3*Matrix(n, shape = identity) + B)" + + assert maple_code(A ** (x ** 2)) == "MatrixPower(A, x^2)" + assert maple_code(A ** 3) == "MatrixPower(A, 3)" + assert maple_code(A ** (S.Half)) == "MatrixPower(A, 1/2)" + + +def test_special_matrices(): + assert maple_code(6 * Identity(3)) == "6*Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], storage = sparse)" + assert maple_code(Identity(x)) == 'Matrix(x, shape = identity)' + + +def test_containers(): + assert maple_code([1, 2, 3, [4, 5, [6, 7]], 8, [9, 10], 11]) == \ + "[1, 2, 3, [4, 5, [6, 7]], 8, [9, 10], 11]" + + assert maple_code((1, 2, (3, 4))) == "[1, 2, [3, 4]]" + assert maple_code([1]) == "[1]" + assert maple_code((1,)) == "[1]" + assert maple_code(Tuple(*[1, 2, 3])) == "[1, 2, 3]" + assert maple_code((1, x * y, (3, x ** 2))) == "[1, x*y, [3, x^2]]" + # scalar, matrix, empty matrix and empty list + + assert maple_code((1, eye(3), Matrix(0, 0, []), [])) == \ + "[1, Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]], storage = rectangular), Matrix([], storage = rectangular), []]" + + +def test_maple_noninline(): + source = maple_code((x + y)/Catalan, assign_to='me', inline=False) + expected = "me := (x + y)/Catalan" + + assert source == expected + + +def test_maple_matrix_assign_to(): + A = Matrix([[1, 2, 3]]) + assert maple_code(A, assign_to='a') == "a := Matrix([[1, 2, 3]], storage = rectangular)" + A = Matrix([[1, 2], [3, 4]]) + assert maple_code(A, assign_to='A') == "A := Matrix([[1, 2], [3, 4]], storage = rectangular)" + + +def test_maple_matrix_assign_to_more(): + # assigning to Symbol or MatrixSymbol requires lhs/rhs match + A = Matrix([[1, 2, 3]]) + B = MatrixSymbol('B', 1, 3) + C = MatrixSymbol('C', 2, 3) + assert maple_code(A, assign_to=B) == "B := Matrix([[1, 2, 3]], storage = rectangular)" + raises(ValueError, lambda: maple_code(A, assign_to=x)) + raises(ValueError, lambda: maple_code(A, assign_to=C)) + + +def test_maple_matrix_1x1(): + A = Matrix([[3]]) + assert maple_code(A, assign_to='B') == "B := Matrix([[3]], storage = rectangular)" + + +def test_maple_matrix_elements(): + A = Matrix([[x, 2, x * y]]) + + assert maple_code(A[0, 0] ** 2 + A[0, 1] + A[0, 2]) == "x^2 + x*y + 2" + AA = MatrixSymbol('AA', 1, 3) + assert maple_code(AA) == "AA" + + assert maple_code(AA[0, 0] ** 2 + sin(AA[0, 1]) + AA[0, 2]) == \ + "sin(AA[1, 2]) + AA[1, 1]^2 + AA[1, 3]" + assert maple_code(sum(AA)) == "AA[1, 1] + AA[1, 2] + AA[1, 3]" + + +def test_maple_boolean(): + assert maple_code(True) == "true" + assert maple_code(S.true) == "true" + assert maple_code(False) == "false" + assert maple_code(S.false) == "false" + + +def test_sparse(): + M = SparseMatrix(5, 6, {}) + M[2, 2] = 10 + M[1, 2] = 20 + M[1, 3] = 22 + M[0, 3] = 30 + M[3, 0] = x * y + assert maple_code(M) == \ + 'Matrix([[0, 0, 0, 30, 0, 0],' \ + ' [0, 0, 20, 22, 0, 0],' \ + ' [0, 0, 10, 0, 0, 0],' \ + ' [x*y, 0, 0, 0, 0, 0],' \ + ' [0, 0, 0, 0, 0, 0]], ' \ + 'storage = sparse)' + +# Not an important point. +def test_maple_not_supported(): + assert maple_code(S.ComplexInfinity) == ( + "# Not supported in maple:\n" + "# ComplexInfinity\n" + "zoo" + ) # PROBLEM + + + +def test_MatrixElement_printing(): + # test cases for issue #11821 + A = MatrixSymbol("A", 1, 3) + B = MatrixSymbol("B", 1, 3) + C = MatrixSymbol("C", 1, 3) + + assert (maple_code(A[0, 0]) == "A[1, 1]") + assert (maple_code(3 * A[0, 0]) == "3*A[1, 1]") + + F = A-B + + assert (maple_code(F[0,0]) == "A[1, 1] - B[1, 1]") + + +def test_hadamard(): + A = MatrixSymbol('A', 3, 3) + B = MatrixSymbol('B', 3, 3) + v = MatrixSymbol('v', 3, 1) + h = MatrixSymbol('h', 1, 3) + C = HadamardProduct(A, B) + assert maple_code(C) == "A*B" + + assert maple_code(C * v) == "(A*B).v" + # HadamardProduct is higher than dot product. + + assert maple_code(h * C * v) == "h.(A*B).v" + + assert maple_code(C * A) == "(A*B).A" + # mixing Hadamard and scalar strange b/c we vectorize scalars + + assert maple_code(C * x * y) == "x*y*(A*B)" + + +def test_maple_piecewise(): + expr = Piecewise((x, x < 1), (x ** 2, True)) + + assert maple_code(expr) == "piecewise(x < 1, x, x^2)" + assert maple_code(expr, assign_to="r") == ( + "r := piecewise(x < 1, x, x^2)") + + expr = Piecewise((x ** 2, x < 1), (x ** 3, x < 2), (x ** 4, x < 3), (x ** 5, True)) + expected = "piecewise(x < 1, x^2, x < 2, x^3, x < 3, x^4, x^5)" + assert maple_code(expr) == expected + assert maple_code(expr, assign_to="r") == "r := " + expected + + # Check that Piecewise without a True (default) condition error + expr = Piecewise((x, x < 1), (x ** 2, x > 1), (sin(x), x > 0)) + raises(ValueError, lambda: maple_code(expr)) + + +def test_maple_piecewise_times_const(): + pw = Piecewise((x, x < 1), (x ** 2, True)) + + assert maple_code(2 * pw) == "2*piecewise(x < 1, x, x^2)" + assert maple_code(pw / x) == "piecewise(x < 1, x, x^2)/x" + assert maple_code(pw / (x * y)) == "piecewise(x < 1, x, x^2)/(x*y)" + assert maple_code(pw / 3) == "(1/3)*piecewise(x < 1, x, x^2)" + + +def test_maple_derivatives(): + f = Function('f') + assert maple_code(f(x).diff(x)) == 'diff(f(x), x)' + assert maple_code(f(x).diff(x, 2)) == 'diff(f(x), x$2)' + + +def test_specfun(): + assert maple_code('asin(x)') == 'arcsin(x)' + assert maple_code(besseli(x, y)) == 'BesselI(x, y)'

diff --git a/.gitignore b/.gitignore index 2614e1546e15..db4a22815e50 100644 --- a/.gitignore +++ b/.gitignore @@ -7,6 +7,8 @@ # track a file that is ignored for some reason, you have to use # "git add -f". See "git help gitignore" for more information. +# Virtualenv +/.venv/ # Regular Python bytecode file *.pyc diff --git a/doc/src/modules/printing.rst b/doc/src/modules/printing.rst index 2adf23a024cb..4729ed9a25b6 100644 --- a/doc/src/modules/printing.rst +++ b/doc/src/modules/printing.rst @@ -301,6 +301,20 @@ Mathematica code printing .. autofunction:: sympy.printing.mathematica.mathematica_code +Maple code printing +------------------- + +.. module:: sympy.printing.maple + +.. autoclass:: sympy.printing.maple.MapleCodePrinter + :members: + + .. autoattribute:: MapleCodePrinter.printmethod + +.. autofunction:: sympy.printing.maple.maple_code + +.. autofunction:: sympy.printing.maple.print_maple_code + Javascript Code printing ------------------------

[ { "components": [ { "doc": "Printer which converts a sympy expression into a maple code.", "lines": [ 77, 262 ], "name": "MapleCodePrinter", "signature": "class MapleCodePrinter(CodePrinter):", "type": "class" }, { "do...

[ "test_Integer", "test_Rational", "test_Relational", "test_Function", "test_Pow", "test_basic_ops", "test_1_over_x_and_sqrt", "test_mix_number_mult_symbols", "test_mix_number_pow_symbols", "test_imag", "test_constants", "test_constants_other", "test_boolean", "test_Matrices", "test_Sparse...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add maple code printer  The development is not finished. But the overall structure established. Please give me some feedback for this. #### References to other Issues or PRs  #### Brief description of what is fixed or changed Add a maple code printer. #### Other comments Still under development. #### Release Notes   * printing * Added a Maple code printer.    ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/printing/maple.py] (definition of MapleCodePrinter:) class MapleCodePrinter(CodePrinter): """Printer which converts a sympy expression into a maple code.""" (definition of MapleCodePrinter.__init__:) def __init__(self, settings=None): (definition of MapleCodePrinter._get_statement:) def _get_statement(self, codestring): (definition of MapleCodePrinter._get_comment:) def _get_comment(self, text): (definition of MapleCodePrinter._declare_number_const:) def _declare_number_const(self, name, value): (definition of MapleCodePrinter._format_code:) def _format_code(self, lines): (definition of MapleCodePrinter._print_tuple:) def _print_tuple(self, expr): (definition of MapleCodePrinter._print_Tuple:) def _print_Tuple(self, expr): (definition of MapleCodePrinter._print_Assignment:) def _print_Assignment(self, expr): (definition of MapleCodePrinter._print_Pow:) def _print_Pow(self, expr, **kwargs): (definition of MapleCodePrinter._print_Piecewise:) def _print_Piecewise(self, expr): (definition of MapleCodePrinter._print_Rational:) def _print_Rational(self, expr): (definition of MapleCodePrinter._print_Relational:) def _print_Relational(self, expr): (definition of MapleCodePrinter._print_NumberSymbol:) def _print_NumberSymbol(self, expr): (definition of MapleCodePrinter._print_NegativeInfinity:) def _print_NegativeInfinity(self, expr): (definition of MapleCodePrinter._print_Infinity:) def _print_Infinity(self, expr): (definition of MapleCodePrinter._print_Idx:) def _print_Idx(self, expr): (definition of MapleCodePrinter._print_BooleanTrue:) def _print_BooleanTrue(self, expr): (definition of MapleCodePrinter._print_BooleanFalse:) def _print_BooleanFalse(self, expr): (definition of MapleCodePrinter._print_bool:) def _print_bool(self, expr): (definition of MapleCodePrinter._print_NaN:) def _print_NaN(self, expr): (definition of MapleCodePrinter._get_matrix:) def _get_matrix(self, expr, sparse=False): (definition of MapleCodePrinter._print_MatrixElement:) def _print_MatrixElement(self, expr): (definition of MapleCodePrinter._print_MatrixBase:) def _print_MatrixBase(self, expr): (definition of MapleCodePrinter._print_SparseMatrix:) def _print_SparseMatrix(self, expr): (definition of MapleCodePrinter._print_Identity:) def _print_Identity(self, expr): (definition of MapleCodePrinter._print_MatMul:) def _print_MatMul(self, expr): (definition of MapleCodePrinter._print_MatPow:) def _print_MatPow(self, expr): (definition of MapleCodePrinter._print_HadamardProduct:) def _print_HadamardProduct(self, expr): (definition of MapleCodePrinter._print_Derivative:) def _print_Derivative(self, expr): (definition of maple_code:) def maple_code(expr, assign_to=None, **settings): """Converts ``expr`` to a string of Maple code. Parameters ========== expr : Expr A sympy expression to be converted. assign_to : optional When given, the argument is used as the name of the variable to which the expression is assigned. Can be a string, ``Symbol``, ``MatrixSymbol``, or ``Indexed`` type. This can be helpful for expressions that generate multi-line statements. precision : integer, optional The precision for numbers such as pi [default=16]. user_functions : dict, optional A dictionary where keys are ``FunctionClass`` instances and values are their string representations. Alternatively, the dictionary value can be a list of tuples i.e. [(argument_test, cfunction_string)]. See below for examples. human : bool, optional If True, the result is a single string that may contain some constant declarations for the number symbols. If False, the same information is returned in a tuple of (symbols_to_declare, not_supported_functions, code_text). [default=True]. contract: bool, optional If True, ``Indexed`` instances are assumed to obey tensor contraction rules and the corresponding nested loops over indices are generated. Setting contract=False will not generate loops, instead the user is responsible to provide values for the indices in the code. [default=True]. inline: bool, optional If True, we try to create single-statement code instead of multiple statements. [default=True].""" (definition of print_maple_code:) def print_maple_code(expr, **settings): """Prints the Maple representation of the given expression. See :func:`maple_code` for the meaning of the optional arguments. Examples ======== >>> from sympy.printing.maple import print_maple_code >>> from sympy import symbols >>> x, y = symbols('x y') >>> print_maple_code(x, assign_to=y) y := x""" [end of new definitions in sympy/printing/maple.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-17239

17,239

sympy/sympy

1.5

8a375578647590e16aff119a2363a12ff171306c

2019-07-21T14:32:26Z

diff --git a/sympy/printing/ccode.py b/sympy/printing/ccode.py index 0aa125278d02..8ee46a3bfd19 100644 --- a/sympy/printing/ccode.py +++ b/sympy/printing/ccode.py @@ -390,7 +390,7 @@ def _print_Relational(self, expr): lhs_code = self._print(expr.lhs) rhs_code = self._print(expr.rhs) op = expr.rel_op - return ("{0} {1} {2}").format(lhs_code, op, rhs_code) + return "{0} {1} {2}".format(lhs_code, op, rhs_code) def _print_sinc(self, expr): from sympy.functions.elementary.trigonometric import sin diff --git a/sympy/printing/codeprinter.py b/sympy/printing/codeprinter.py index 7dd729560803..fb9caa35e4e9 100644 --- a/sympy/printing/codeprinter.py +++ b/sympy/printing/codeprinter.py @@ -532,3 +532,4 @@ def _print_not_supported(self, expr): _print_Unit = _print_not_supported _print_Wild = _print_not_supported _print_WildFunction = _print_not_supported + _print_Relational = _print_not_supported diff --git a/sympy/printing/fcode.py b/sympy/printing/fcode.py index 9b3cb0727922..4648ba8da8e7 100644 --- a/sympy/printing/fcode.py +++ b/sympy/printing/fcode.py @@ -365,6 +365,13 @@ def _print_Float(self, expr): return "%sd%s" % (printed[:e], printed[e + 1:]) return "%sd0" % printed + def _print_Relational(self, expr): + lhs_code = self._print(expr.lhs) + rhs_code = self._print(expr.rhs) + op = expr.rel_op + op = op if op not in self._relationals else self._relationals[op] + return "{0} {1} {2}".format(lhs_code, op, rhs_code) + def _print_Indexed(self, expr): inds = [ self._print(i) for i in expr.indices ] return "%s(%s)" % (self._print(expr.base.label), ", ".join(inds)) @@ -425,14 +432,6 @@ def _print_For(self, expr): 'end do').format(target=target, start=start, stop=stop, step=step, body=body) - def _print_Equality(self, expr): - lhs, rhs = expr.args - return ' == '.join(map(lambda arg: self._print(arg), (lhs, rhs))) - - def _print_Unequality(self, expr): - lhs, rhs = expr.args - return ' /= '.join(map(lambda arg: self._print(arg), (lhs, rhs))) - def _print_Type(self, type_): type_ = self.type_aliases.get(type_, type_) type_str = self.type_mappings.get(type_, type_.name) diff --git a/sympy/printing/glsl.py b/sympy/printing/glsl.py index db8e6694cdd7..d04c49fe5c67 100644 --- a/sympy/printing/glsl.py +++ b/sympy/printing/glsl.py @@ -281,6 +281,12 @@ def _print_int(self, expr): def _print_Rational(self, expr): return "%s.0/%s.0" % (expr.p, expr.q) + def _print_Relational(self, expr): + lhs_code = self._print(expr.lhs) + rhs_code = self._print(expr.rhs) + op = expr.rel_op + return "{0} {1} {2}".format(lhs_code, op, rhs_code) + def _print_Add(self, expr, order=None): if self._settings['use_operators']: return CodePrinter._print_Add(self, expr, order=order) diff --git a/sympy/printing/jscode.py b/sympy/printing/jscode.py index 6f456e45fd6a..2e77de3f38dd 100644 --- a/sympy/printing/jscode.py +++ b/sympy/printing/jscode.py @@ -113,6 +113,12 @@ def _print_Rational(self, expr): p, q = int(expr.p), int(expr.q) return '%d/%d' % (p, q) + def _print_Relational(self, expr): + lhs_code = self._print(expr.lhs) + rhs_code = self._print(expr.rhs) + op = expr.rel_op + return "{0} {1} {2}".format(lhs_code, op, rhs_code) + def _print_Indexed(self, expr): # calculate index for 1d array dims = expr.shape diff --git a/sympy/printing/julia.py b/sympy/printing/julia.py index b0a75b94b377..973ee56736f1 100644 --- a/sympy/printing/julia.py +++ b/sympy/printing/julia.py @@ -190,6 +190,11 @@ def multjoin(a, a_str): return (sign + multjoin(a, a_str) + divsym + "(%s)" % multjoin(b, b_str)) + def _print_Relational(self, expr): + lhs_code = self._print(expr.lhs) + rhs_code = self._print(expr.rhs) + op = expr.rel_op + return "{0} {1} {2}".format(lhs_code, op, rhs_code) def _print_Pow(self, expr): powsymbol = '^' if all([x.is_number for x in expr.args]) else '.^' diff --git a/sympy/printing/mathematica.py b/sympy/printing/mathematica.py index 9ee83f13fde9..0ffb0f137713 100644 --- a/sympy/printing/mathematica.py +++ b/sympy/printing/mathematica.py @@ -157,6 +157,11 @@ def _print_Mul(self, expr): res += '**'.join(self.parenthesize(a, PREC) for a in nc) return res + def _print_Relational(self, expr): + lhs_code = self._print(expr.lhs) + rhs_code = self._print(expr.rhs) + op = expr.rel_op + return "{0} {1} {2}".format(lhs_code, op, rhs_code) # Primitive numbers def _print_Zero(self, expr): diff --git a/sympy/printing/octave.py b/sympy/printing/octave.py index 684431e19b2f..e76e5cc44575 100644 --- a/sympy/printing/octave.py +++ b/sympy/printing/octave.py @@ -209,6 +209,11 @@ def multjoin(a, a_str): return (sign + multjoin(a, a_str) + divsym + "(%s)" % multjoin(b, b_str)) + def _print_Relational(self, expr): + lhs_code = self._print(expr.lhs) + rhs_code = self._print(expr.rhs) + op = expr.rel_op + return "{0} {1} {2}".format(lhs_code, op, rhs_code) def _print_Pow(self, expr): powsymbol = '^' if all([x.is_number for x in expr.args]) else '.^' diff --git a/sympy/printing/rcode.py b/sympy/printing/rcode.py index 11a78a8be39d..11e02d34dc08 100644 --- a/sympy/printing/rcode.py +++ b/sympy/printing/rcode.py @@ -246,7 +246,7 @@ def _print_Relational(self, expr): lhs_code = self._print(expr.lhs) rhs_code = self._print(expr.rhs) op = expr.rel_op - return ("{0} {1} {2}").format(lhs_code, op, rhs_code) + return "{0} {1} {2}".format(lhs_code, op, rhs_code) def _print_sinc(self, expr): from sympy.functions.elementary.trigonometric import sin diff --git a/sympy/printing/rust.py b/sympy/printing/rust.py index 5ccb50819156..5edb5b4301c8 100644 --- a/sympy/printing/rust.py +++ b/sympy/printing/rust.py @@ -358,6 +358,12 @@ def _print_Rational(self, expr): p, q = int(expr.p), int(expr.q) return '%d_f64/%d.0' % (p, q) + def _print_Relational(self, expr): + lhs_code = self._print(expr.lhs) + rhs_code = self._print(expr.rhs) + op = expr.rel_op + return "{0} {1} {2}".format(lhs_code, op, rhs_code) + def _print_Indexed(self, expr): # calculate index for 1d array dims = expr.shape

diff --git a/sympy/printing/tests/test_glsl.py b/sympy/printing/tests/test_glsl.py index 76ab05be2293..53a39d2595cb 100644 --- a/sympy/printing/tests/test_glsl.py +++ b/sympy/printing/tests/test_glsl.py @@ -1,4 +1,5 @@ -from sympy.core import pi, oo, symbols, Rational, Integer, GoldenRatio, EulerGamma, Catalan, Lambda, Dummy +from sympy.core import (pi, symbols, Rational, Integer, GoldenRatio, EulerGamma, + Catalan, Lambda, Dummy, Eq, Ne, Le, Lt, Gt, Ge) from sympy.functions import Piecewise, sin, cos, Abs, exp, ceiling, sqrt from sympy.utilities.pytest import raises from sympy.printing.glsl import GLSLPrinter @@ -37,6 +38,15 @@ def test_glsl_code_Pow(): assert glsl_code(x**-1.0) == '1.0/x' +def test_glsl_code_Relational(): + assert glsl_code(Eq(x, y)) == "x == y" + assert glsl_code(Ne(x, y)) == "x != y" + assert glsl_code(Le(x, y)) == "x <= y" + assert glsl_code(Lt(x, y)) == "x < y" + assert glsl_code(Gt(x, y)) == "x > y" + assert glsl_code(Ge(x, y)) == "x >= y" + + def test_glsl_code_constants_mathh(): assert glsl_code(exp(1)) == "float E = 2.71828183;\nE" assert glsl_code(pi) == "float pi = 3.14159265;\npi" diff --git a/sympy/printing/tests/test_jscode.py b/sympy/printing/tests/test_jscode.py index ff228d2a1206..6b24c98adfd0 100644 --- a/sympy/printing/tests/test_jscode.py +++ b/sympy/printing/tests/test_jscode.py @@ -1,5 +1,6 @@ from sympy.core import (pi, oo, symbols, Rational, Integer, GoldenRatio, - EulerGamma, Catalan, Lambda, Dummy, S) + EulerGamma, Catalan, Lambda, Dummy, S, Eq, Ne, Le, + Lt, Gt, Ge) from sympy.functions import (Piecewise, sin, cos, Abs, exp, ceiling, sqrt, sinh, cosh, tanh, asin, acos, acosh, Max, Min) from sympy.utilities.pytest import raises @@ -54,6 +55,16 @@ def test_jscode_Rational(): assert jscode(Rational(-3, -7)) == "3/7" +def test_Relational(): + assert jscode(Eq(x, y)) == "x == y" + assert jscode(Ne(x, y)) == "x != y" + assert jscode(Le(x, y)) == "x <= y" + assert jscode(Lt(x, y)) == "x < y" + assert jscode(Gt(x, y)) == "x > y" + assert jscode(Ge(x, y)) == "x >= y" + + + def test_jscode_Integer(): assert jscode(Integer(67)) == "67" assert jscode(Integer(-1)) == "-1" diff --git a/sympy/printing/tests/test_julia.py b/sympy/printing/tests/test_julia.py index 4aea0db1fc4d..26cf9419b6a5 100644 --- a/sympy/printing/tests/test_julia.py +++ b/sympy/printing/tests/test_julia.py @@ -1,5 +1,5 @@ from sympy.core import (S, pi, oo, symbols, Function, Rational, Integer, - Tuple, Symbol) + Tuple, Symbol, Eq, Ne, Le, Lt, Gt, Ge) from sympy.core import EulerGamma, GoldenRatio, Catalan, Lambda, Mul, Pow from sympy.functions import Piecewise, sqrt, ceiling, exp, sin, cos from sympy.utilities.pytest import raises @@ -10,7 +10,6 @@ besselk, hankel1, hankel2, airyai, airybi, airyaiprime, airybiprime) from sympy.utilities.pytest import XFAIL -from sympy.core.compatibility import range from sympy import julia_code @@ -31,6 +30,15 @@ def test_Rational(): assert julia_code(Rational(3, 7)*x) == "3*x/7" +def test_Relational(): + assert julia_code(Eq(x, y)) == "x == y" + assert julia_code(Ne(x, y)) == "x != y" + assert julia_code(Le(x, y)) == "x <= y" + assert julia_code(Lt(x, y)) == "x < y" + assert julia_code(Gt(x, y)) == "x > y" + assert julia_code(Ge(x, y)) == "x >= y" + + def test_Function(): assert julia_code(sin(x) ** cos(x)) == "sin(x).^cos(x)" assert julia_code(abs(x)) == "abs(x)" diff --git a/sympy/printing/tests/test_mathematica.py b/sympy/printing/tests/test_mathematica.py index 787df1af45d7..a2aa5cc16afe 100644 --- a/sympy/printing/tests/test_mathematica.py +++ b/sympy/printing/tests/test_mathematica.py @@ -1,5 +1,5 @@ -from sympy.core import (S, pi, oo, symbols, Function, - Rational, Integer, Tuple, Derivative) +from sympy.core import (S, pi, oo, symbols, Function, Rational, Integer, Tuple, + Derivative, Eq, Ne, Le, Lt, Gt, Ge) from sympy.integrals import Integral from sympy.concrete import Sum from sympy.functions import (exp, sin, cos, fresnelc, fresnels, conjugate, Max, @@ -32,6 +32,15 @@ def test_Rational(): assert mcode(Rational(3, 7)*x) == "(3/7)*x" +def test_Relational(): + assert mcode(Eq(x, y)) == "x == y" + assert mcode(Ne(x, y)) == "x != y" + assert mcode(Le(x, y)) == "x <= y" + assert mcode(Lt(x, y)) == "x < y" + assert mcode(Gt(x, y)) == "x > y" + assert mcode(Ge(x, y)) == "x >= y" + + def test_Function(): assert mcode(f(x, y, z)) == "f[x, y, z]" assert mcode(sin(x) ** cos(x)) == "Sin[x]^Cos[x]" diff --git a/sympy/printing/tests/test_octave.py b/sympy/printing/tests/test_octave.py index a56c68158379..df3b695110d8 100644 --- a/sympy/printing/tests/test_octave.py +++ b/sympy/printing/tests/test_octave.py @@ -1,6 +1,6 @@ from sympy.core import (S, pi, oo, symbols, Function, Rational, Integer, Tuple, Symbol, EulerGamma, GoldenRatio, Catalan, - Lambda, Mul, Pow, Mod) + Lambda, Mul, Pow, Mod, Eq, Ne, Le, Lt, Gt, Ge) from sympy.codegen.matrix_nodes import MatrixSolve from sympy.functions import (arg, atan2, bernoulli, beta, ceiling, chebyshevu, chebyshevt, conjugate, DiracDelta, exp, expint, @@ -25,10 +25,6 @@ erfcinv, erfinv, fresnelc, fresnels, li, Shi, Si, Li, erf2) -from sympy.polys.polytools import gcd, lcm -from sympy.ntheory.primetest import isprime -from sympy.core.compatibility import range - from sympy import octave_code from sympy import octave_code as mcode @@ -49,6 +45,15 @@ def test_Rational(): assert mcode(Rational(3, 7)*x) == "3*x/7" +def test_Relational(): + assert mcode(Eq(x, y)) == "x == y" + assert mcode(Ne(x, y)) == "x != y" + assert mcode(Le(x, y)) == "x <= y" + assert mcode(Lt(x, y)) == "x < y" + assert mcode(Gt(x, y)) == "x > y" + assert mcode(Ge(x, y)) == "x >= y" + + def test_Function(): assert mcode(sin(x) ** cos(x)) == "sin(x).^cos(x)" assert mcode(sign(x)) == "sign(x)" diff --git a/sympy/printing/tests/test_rust.py b/sympy/printing/tests/test_rust.py index 2e1a5d8c029d..afa0d48374cb 100644 --- a/sympy/printing/tests/test_rust.py +++ b/sympy/printing/tests/test_rust.py @@ -1,13 +1,12 @@ from sympy.core import (S, pi, oo, symbols, Rational, Integer, - GoldenRatio, EulerGamma, Catalan, Lambda, Dummy, Eq) + GoldenRatio, EulerGamma, Catalan, Lambda, Dummy, + Eq, Ne, Le, Lt, Gt, Ge) from sympy.functions import (Piecewise, sin, cos, Abs, exp, ceiling, sqrt, - gamma, sign) + sign) from sympy.logic import ITE from sympy.utilities.pytest import raises -from sympy.printing.rust import RustCodePrinter from sympy.utilities.lambdify import implemented_function from sympy.tensor import IndexedBase, Idx -from sympy.matrices import Matrix, MatrixSymbol from sympy import rust_code @@ -19,6 +18,15 @@ def test_Integer(): assert rust_code(Integer(-56)) == "-56" +def test_Relational(): + assert rust_code(Eq(x, y)) == "x == y" + assert rust_code(Ne(x, y)) == "x != y" + assert rust_code(Le(x, y)) == "x <= y" + assert rust_code(Lt(x, y)) == "x < y" + assert rust_code(Gt(x, y)) == "x > y" + assert rust_code(Ge(x, y)) == "x >= y" + + def test_Rational(): assert rust_code(Rational(3, 7)) == "3_f64/7.0" assert rust_code(Rational(18, 9)) == "2"

[ { "components": [ { "doc": "", "lines": [ 368, 373 ], "name": "FCodePrinter._print_Relational", "signature": "def _print_Relational(self, expr):", "type": "function" } ], "file": "sympy/printing/fcode.py" }, { "compo...

[ "test_glsl_code_Relational", "test_Relational" ]

[ "test_printmethod", "test_print_without_operators", "test_glsl_code_sqrt", "test_glsl_code_Pow", "test_glsl_code_constants_mathh", "test_glsl_code_constants_other", "test_glsl_code_Rational", "test_glsl_code_Integer", "test_glsl_code_functions", "test_glsl_code_inline_function", "test_glsl_code_...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added relational operator printer for various languages  #### References to other Issues or PRs  Fixes #17238 #### Brief description of what is fixed or changed Added relational operator printer for following languages: 1. glsl 2. js 3. julia 4. mathematica 5. octave 6. rust I have also verified that they are correct. Added tests for same. Ping @sylee957 #### Other comments #### Release Notes   - printing - added relational operator printing for various languages  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/printing/fcode.py] (definition of FCodePrinter._print_Relational:) def _print_Relational(self, expr): [end of new definitions in sympy/printing/fcode.py] [start of new definitions in sympy/printing/glsl.py] (definition of GLSLPrinter._print_Relational:) def _print_Relational(self, expr): [end of new definitions in sympy/printing/glsl.py] [start of new definitions in sympy/printing/jscode.py] (definition of JavascriptCodePrinter._print_Relational:) def _print_Relational(self, expr): [end of new definitions in sympy/printing/jscode.py] [start of new definitions in sympy/printing/julia.py] (definition of JuliaCodePrinter._print_Relational:) def _print_Relational(self, expr): [end of new definitions in sympy/printing/julia.py] [start of new definitions in sympy/printing/mathematica.py] (definition of MCodePrinter._print_Relational:) def _print_Relational(self, expr): [end of new definitions in sympy/printing/mathematica.py] [start of new definitions in sympy/printing/octave.py] (definition of OctaveCodePrinter._print_Relational:) def _print_Relational(self, expr): [end of new definitions in sympy/printing/octave.py] [start of new definitions in sympy/printing/rust.py] (definition of RustCodePrinter._print_Relational:) def _print_Relational(self, expr): [end of new definitions in sympy/printing/rust.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Relational printing ```python3 from sympy import * from sympy.printing.ccode import ccode from sympy.printing.cxxcode import cxxcode from sympy.printing.fcode import fcode from sympy.printing.glsl import glsl_code from sympy.printing.jscode import jscode from sympy.printing.julia import julia_code from sympy.printing.mathematica import mathematica_code from sympy.printing.octave import octave_code from sympy.printing.pycode import pycode from sympy.printing.rcode import rcode from sympy.printing.rust import rust_code x = Symbol('x') print(ccode(Eq(x, 1))) print(cxxcode(Eq(x, 1))) print(glsl_code(Eq(x, 1))) print(fcode(Eq(x, 1))) print(jscode(Eq(x, 1))) print(julia_code(Eq(x, 1))) print(mathematica_code(Eq(x, 1))) print(octave_code(Eq(x, 1))) print(pycode(Eq(x, 1))) print(rcode(Eq(x, 1))) print(rust_code(Eq(x, 1))) ``` Result ``` x == 1 x == 1 Eq(x, 1) x == 1 Eq(x, 1) Eq(x, 1) Eq(x, 1) Eq(x, 1) (x == 1) x == 1 Eq(x, 1) ``` glsl, javascript, julia, mathematica, octave, rust code printers are probably printing equality in a wrong way. They are false-positively looking up for `StrPrinter._print_Relational` C or Fortran printers are overriding `_print_Relational`, so they are the only things working. ---------- -------------------- </issues>

c72f122f67553e1af930bac6c35732d2a0bbb776

scikit-learn__scikit-learn-14307

14,307

scikit-learn/scikit-learn

0.22

bf8eff3feaded1464e81dcc0c4b7f9a3975c014f

2019-07-12T09:47:52Z

diff --git a/sklearn/cluster/k_means_.py b/sklearn/cluster/k_means_.py index 8f8d8f66c405e..33815b2c177f0 100644 --- a/sklearn/cluster/k_means_.py +++ b/sklearn/cluster/k_means_.py @@ -27,7 +27,7 @@ from ..utils import check_array from ..utils import gen_batches from ..utils import check_random_state -from ..utils.validation import check_is_fitted +from ..utils.validation import check_is_fitted, _check_sample_weight from ..utils.validation import FLOAT_DTYPES from ..exceptions import ConvergenceWarning from . import _k_means @@ -164,19 +164,19 @@ def _tolerance(X, tol): return np.mean(variances) * tol -def _check_sample_weight(X, sample_weight): +def _check_normalize_sample_weight(sample_weight, X): """Set sample_weight if None, and check for correct dtype""" - n_samples = X.shape[0] - if sample_weight is None: - return np.ones(n_samples, dtype=X.dtype) - else: - sample_weight = np.asarray(sample_weight) - if n_samples != len(sample_weight): - raise ValueError("n_samples=%d should be == len(sample_weight)=%d" - % (n_samples, len(sample_weight))) + + sample_weight_was_none = sample_weight is None + + sample_weight = _check_sample_weight(sample_weight, X, dtype=X.dtype) + if not sample_weight_was_none: # normalize the weights to sum up to n_samples + # an array of 1 (i.e. samples_weight is None) is already normalized + n_samples = len(sample_weight) scale = n_samples / sample_weight.sum() - return (sample_weight * scale).astype(X.dtype, copy=False) + sample_weight *= scale + return sample_weight def k_means(X, n_clusters, sample_weight=None, init='k-means++', @@ -434,7 +434,7 @@ def _kmeans_single_elkan(X, sample_weight, n_clusters, max_iter=300, if verbose: print('Initialization complete') - checked_sample_weight = _check_sample_weight(X, sample_weight) + checked_sample_weight = _check_normalize_sample_weight(sample_weight, X) centers, labels, n_iter = k_means_elkan(X, checked_sample_weight, n_clusters, centers, tol=tol, max_iter=max_iter, verbose=verbose) @@ -519,7 +519,7 @@ def _kmeans_single_lloyd(X, sample_weight, n_clusters, max_iter=300, """ random_state = check_random_state(random_state) - sample_weight = _check_sample_weight(X, sample_weight) + sample_weight = _check_normalize_sample_weight(sample_weight, X) best_labels, best_inertia, best_centers = None, None, None # init @@ -662,7 +662,7 @@ def _labels_inertia(X, sample_weight, x_squared_norms, centers, Sum of squared distances of samples to their closest cluster center. """ n_samples = X.shape[0] - sample_weight = _check_sample_weight(X, sample_weight) + sample_weight = _check_normalize_sample_weight(sample_weight, X) # set the default value of centers to -1 to be able to detect any anomaly # easily labels = np.full(n_samples, -1, np.int32) @@ -1492,7 +1492,7 @@ def fit(self, X, y=None, sample_weight=None): raise ValueError("n_samples=%d should be >= n_clusters=%d" % (n_samples, self.n_clusters)) - sample_weight = _check_sample_weight(X, sample_weight) + sample_weight = _check_normalize_sample_weight(sample_weight, X) n_init = self.n_init if hasattr(self.init, '__array__'): @@ -1641,7 +1641,7 @@ def _labels_inertia_minibatch(self, X, sample_weight): """ if self.verbose: print('Computing label assignment and total inertia') - sample_weight = _check_sample_weight(X, sample_weight) + sample_weight = _check_normalize_sample_weight(sample_weight, X) x_squared_norms = row_norms(X, squared=True) slices = gen_batches(X.shape[0], self.batch_size) results = [_labels_inertia(X[s], sample_weight[s], x_squared_norms[s], @@ -1676,7 +1676,7 @@ def partial_fit(self, X, y=None, sample_weight=None): if n_samples == 0: return self - sample_weight = _check_sample_weight(X, sample_weight) + sample_weight = _check_normalize_sample_weight(sample_weight, X) x_squared_norms = row_norms(X, squared=True) self.random_state_ = getattr(self, "random_state_", diff --git a/sklearn/linear_model/huber.py b/sklearn/linear_model/huber.py index 8664f3edb94dc..e518feae29b78 100644 --- a/sklearn/linear_model/huber.py +++ b/sklearn/linear_model/huber.py @@ -8,8 +8,8 @@ from ..base import BaseEstimator, RegressorMixin from .base import LinearModel from ..utils import check_X_y -from ..utils import check_consistent_length from ..utils import axis0_safe_slice +from ..utils.validation import _check_sample_weight from ..utils.extmath import safe_sparse_dot from ..utils.optimize import _check_optimize_result @@ -255,11 +255,8 @@ def fit(self, X, y, sample_weight=None): X, y = check_X_y( X, y, copy=False, accept_sparse=['csr'], y_numeric=True, dtype=[np.float64, np.float32]) - if sample_weight is not None: - sample_weight = np.array(sample_weight) - check_consistent_length(y, sample_weight) - else: - sample_weight = np.ones_like(y) + + sample_weight = _check_sample_weight(sample_weight, X) if self.epsilon < 1.0: raise ValueError( diff --git a/sklearn/linear_model/logistic.py b/sklearn/linear_model/logistic.py index decd345a9bdbb..10a4d32e51275 100644 --- a/sklearn/linear_model/logistic.py +++ b/sklearn/linear_model/logistic.py @@ -30,7 +30,7 @@ from ..utils.fixes import logsumexp from ..utils.optimize import newton_cg, _check_optimize_result from ..utils.validation import check_X_y -from ..utils.validation import check_is_fitted +from ..utils.validation import check_is_fitted, _check_sample_weight from ..utils import deprecated from ..exceptions import ChangedBehaviorWarning from ..utils.multiclass import check_classification_targets @@ -826,11 +826,8 @@ def _logistic_regression_path(X, y, pos_class=None, Cs=10, fit_intercept=True, # If sample weights exist, convert them to array (support for lists) # and check length # Otherwise set them to 1 for all examples - if sample_weight is not None: - sample_weight = np.array(sample_weight, dtype=X.dtype, order='C') - check_consistent_length(y, sample_weight) - else: - sample_weight = np.ones(X.shape[0], dtype=X.dtype) + sample_weight = _check_sample_weight(sample_weight, X, + dtype=X.dtype) # If class_weights is a dict (provided by the user), the weights # are assigned to the original labels. If it is "balanced", then @@ -1133,9 +1130,7 @@ def _log_reg_scoring_path(X, y, train, test, pos_class=None, Cs=10, y_test = y[test] if sample_weight is not None: - sample_weight = check_array(sample_weight, ensure_2d=False) - check_consistent_length(y, sample_weight) - + sample_weight = _check_sample_weight(sample_weight, X) sample_weight = sample_weight[train] coefs, Cs, n_iter = _logistic_regression_path( diff --git a/sklearn/linear_model/ransac.py b/sklearn/linear_model/ransac.py index 7f4fb650b59e8..b901e848f49bf 100644 --- a/sklearn/linear_model/ransac.py +++ b/sklearn/linear_model/ransac.py @@ -11,7 +11,7 @@ from ..base import MultiOutputMixin from ..utils import check_random_state, check_array, check_consistent_length from ..utils.random import sample_without_replacement -from ..utils.validation import check_is_fitted +from ..utils.validation import check_is_fitted, _check_sample_weight from .base import LinearRegression from ..utils.validation import has_fit_parameter from ..exceptions import ConvergenceWarning @@ -324,8 +324,7 @@ def fit(self, X, y, sample_weight=None): raise ValueError("%s does not support sample_weight. Samples" " weights are only used for the calibration" " itself." % estimator_name) - if sample_weight is not None: - sample_weight = np.asarray(sample_weight) + sample_weight = _check_sample_weight(sample_weight, X) n_inliers_best = 1 score_best = -np.inf diff --git a/sklearn/linear_model/ridge.py b/sklearn/linear_model/ridge.py index 45862d5f3cffb..cc3b6a518add5 100644 --- a/sklearn/linear_model/ridge.py +++ b/sklearn/linear_model/ridge.py @@ -27,6 +27,7 @@ from ..utils import check_consistent_length from ..utils import compute_sample_weight from ..utils import column_or_1d +from ..utils.validation import _check_sample_weight from ..preprocessing import LabelBinarizer from ..model_selection import GridSearchCV from ..metrics.scorer import check_scoring @@ -428,8 +429,7 @@ def _ridge_regression(X, y, alpha, sample_weight=None, solver='auto', " %d != %d" % (n_samples, n_samples_)) if has_sw: - if np.atleast_1d(sample_weight).ndim > 1: - raise ValueError("Sample weights must be 1D array or scalar") + sample_weight = _check_sample_weight(sample_weight, X, dtype=X.dtype) if solver not in ['sag', 'saga']: # SAG supports sample_weight directly. For other solvers, @@ -1406,9 +1406,8 @@ def fit(self, X, y, sample_weight=None): "alphas must be positive. Got {} containing some " "negative or null value instead.".format(self.alphas)) - if sample_weight is not None and not isinstance(sample_weight, float): - sample_weight = check_array(sample_weight, ensure_2d=False, - dtype=X.dtype) + sample_weight = _check_sample_weight(sample_weight, X, dtype=X.dtype) + n_samples, n_features = X.shape X, y, X_offset, y_offset, X_scale = LinearModel._preprocess_data( diff --git a/sklearn/linear_model/sag.py b/sklearn/linear_model/sag.py index 233a6ed1c50af..fa02c7a4a0ef8 100644 --- a/sklearn/linear_model/sag.py +++ b/sklearn/linear_model/sag.py @@ -12,6 +12,7 @@ from .sag_fast import sag32, sag64 from ..exceptions import ConvergenceWarning from ..utils import check_array +from ..utils.validation import _check_sample_weight from ..utils.extmath import row_norms @@ -251,8 +252,7 @@ def sag_solver(X, y, sample_weight=None, loss='log', alpha=1., beta=0., n_classes = int(y.max()) + 1 if loss == 'multinomial' else 1 # initialization - if sample_weight is None: - sample_weight = np.ones(n_samples, dtype=X.dtype, order='C') + sample_weight = _check_sample_weight(sample_weight, X, dtype=X.dtype) if 'coef' in warm_start_mem.keys(): coef_init = warm_start_mem['coef'] diff --git a/sklearn/linear_model/stochastic_gradient.py b/sklearn/linear_model/stochastic_gradient.py index 625bdb5bdc3f9..25b63a3a0cdce 100644 --- a/sklearn/linear_model/stochastic_gradient.py +++ b/sklearn/linear_model/stochastic_gradient.py @@ -18,7 +18,7 @@ from ..utils import check_array, check_random_state, check_X_y from ..utils.extmath import safe_sparse_dot from ..utils.multiclass import _check_partial_fit_first_call -from ..utils.validation import check_is_fitted +from ..utils.validation import check_is_fitted, _check_sample_weight from ..exceptions import ConvergenceWarning from ..model_selection import StratifiedShuffleSplit, ShuffleSplit @@ -169,19 +169,6 @@ def _get_penalty_type(self, penalty): except KeyError: raise ValueError("Penalty %s is not supported. " % penalty) - def _validate_sample_weight(self, sample_weight, n_samples): - """Set the sample weight array.""" - if sample_weight is None: - # uniform sample weights - sample_weight = np.ones(n_samples, dtype=np.float64, order='C') - else: - # user-provided array - sample_weight = np.asarray(sample_weight, dtype=np.float64, - order="C") - if sample_weight.shape[0] != n_samples: - raise ValueError("Shapes of X and sample_weight do not match.") - return sample_weight - def _allocate_parameter_mem(self, n_classes, n_features, coef_init=None, intercept_init=None): """Allocate mem for parameters; initialize if provided.""" @@ -488,7 +475,7 @@ def _partial_fit(self, X, y, alpha, C, # Allocate datastructures from input arguments self._expanded_class_weight = compute_class_weight(self.class_weight, self.classes_, y) - sample_weight = self._validate_sample_weight(sample_weight, n_samples) + sample_weight = _check_sample_weight(sample_weight, X) if getattr(self, "coef_", None) is None or coef_init is not None: self._allocate_parameter_mem(n_classes, n_features, @@ -1095,9 +1082,9 @@ def _partial_fit(self, X, y, alpha, C, loss, learning_rate, n_samples, n_features = X.shape - # Allocate datastructures from input arguments - sample_weight = self._validate_sample_weight(sample_weight, n_samples) + sample_weight = _check_sample_weight(sample_weight, X) + # Allocate datastructures from input arguments if getattr(self, "coef_", None) is None: self._allocate_parameter_mem(1, n_features, coef_init, intercept_init) diff --git a/sklearn/svm/base.py b/sklearn/svm/base.py index 4a50ee479f030..e27abeed7ecee 100644 --- a/sklearn/svm/base.py +++ b/sklearn/svm/base.py @@ -8,11 +8,12 @@ from ..base import BaseEstimator, ClassifierMixin from ..preprocessing import LabelEncoder from ..utils.multiclass import _ovr_decision_function -from ..utils import check_array, check_consistent_length, check_random_state +from ..utils import check_array, check_random_state from ..utils import column_or_1d, check_X_y from ..utils import compute_class_weight from ..utils.extmath import safe_sparse_dot from ..utils.validation import check_is_fitted, _check_large_sparse +from ..utils.validation import _check_sample_weight from ..utils.multiclass import check_classification_targets from ..exceptions import ConvergenceWarning from ..exceptions import NotFittedError @@ -906,11 +907,9 @@ def _fit_liblinear(X, y, C, fit_intercept, intercept_scaling, class_weight, # LibLinear wants targets as doubles, even for classification y_ind = np.asarray(y_ind, dtype=np.float64).ravel() y_ind = np.require(y_ind, requirements="W") - if sample_weight is None: - sample_weight = np.ones(X.shape[0]) - else: - sample_weight = np.array(sample_weight, dtype=np.float64, order='C') - check_consistent_length(sample_weight, X) + + sample_weight = _check_sample_weight(sample_weight, X, + dtype=np.float64) solver_type = _get_liblinear_solver_type(multi_class, penalty, loss, dual) raw_coef_, n_iter_ = liblinear.train_wrap( diff --git a/sklearn/utils/validation.py b/sklearn/utils/validation.py index bb6cf1c8ffe00..abf51eef8f487 100644 --- a/sklearn/utils/validation.py +++ b/sklearn/utils/validation.py @@ -980,3 +980,53 @@ def check_scalar(x, name, target_type, min_val=None, max_val=None): if max_val is not None and x > max_val: raise ValueError('`{}`= {}, must be <= {}.'.format(name, x, max_val)) + + +def _check_sample_weight(sample_weight, X, dtype=None): + """Validate sample weights. + + Parameters + ---------- + sample_weight : {ndarray, Number or None}, shape (n_samples,) + Input sample weights. + + X : nd-array, list or sparse matrix + Input data. + + dtype: dtype + dtype of the validated `sample_weight`. + If None, and the input `sample_weight` is an array, the dtype of the + input is preserved; otherwise an array with the default numpy dtype + is be allocated. If `dtype` is not one of `float32`, `float64`, + `None`, the output will be of dtype `float64`. + + Returns + ------- + sample_weight : ndarray, shape (n_samples,) + Validated sample weight. It is guaranteed to be "C" contiguous. + """ + n_samples = _num_samples(X) + + if dtype is not None and dtype not in [np.float32, np.float64]: + dtype = np.float64 + + if sample_weight is None or isinstance(sample_weight, numbers.Number): + if sample_weight is None: + sample_weight = np.ones(n_samples, dtype=dtype) + else: + sample_weight = np.full(n_samples, sample_weight, + dtype=dtype) + else: + if dtype is None: + dtype = [np.float64, np.float32] + sample_weight = check_array( + sample_weight, accept_sparse=False, + ensure_2d=False, dtype=dtype, order="C" + ) + if sample_weight.ndim != 1: + raise ValueError("Sample weights must be 1D array or scalar") + + if sample_weight.shape != (n_samples,): + raise ValueError("sample_weight.shape == {}, expected {}!" + .format(sample_weight.shape, (n_samples,))) + return sample_weight

diff --git a/sklearn/cluster/tests/test_k_means.py b/sklearn/cluster/tests/test_k_means.py index 4266dc6a17899..362b0a9145fca 100644 --- a/sklearn/cluster/tests/test_k_means.py +++ b/sklearn/cluster/tests/test_k_means.py @@ -909,14 +909,15 @@ def test_sample_weight_length(): # check that an error is raised when passing sample weights # with an incompatible shape km = KMeans(n_clusters=n_clusters, random_state=42) - assert_raises_regex(ValueError, r'len$sample_weight$', km.fit, X, - sample_weight=np.ones(2)) + msg = r'sample_weight.shape == $2,$, expected $100,$' + with pytest.raises(ValueError, match=msg): + km.fit(X, sample_weight=np.ones(2)) -def test_check_sample_weight(): - from sklearn.cluster.k_means_ import _check_sample_weight +def test_check_normalize_sample_weight(): + from sklearn.cluster.k_means_ import _check_normalize_sample_weight sample_weight = None - checked_sample_weight = _check_sample_weight(X, sample_weight) + checked_sample_weight = _check_normalize_sample_weight(sample_weight, X) assert _num_samples(X) == _num_samples(checked_sample_weight) assert_almost_equal(checked_sample_weight.sum(), _num_samples(X)) assert X.dtype == checked_sample_weight.dtype diff --git a/sklearn/utils/tests/test_validation.py b/sklearn/utils/tests/test_validation.py index 0aa8eae22b1e2..2789a59344008 100644 --- a/sklearn/utils/tests/test_validation.py +++ b/sklearn/utils/tests/test_validation.py @@ -20,6 +20,7 @@ from sklearn.utils.testing import SkipTest from sklearn.utils.testing import assert_array_equal from sklearn.utils.testing import assert_allclose_dense_sparse +from sklearn.utils.testing import assert_allclose from sklearn.utils import as_float_array, check_array, check_symmetric from sklearn.utils import check_X_y from sklearn.utils import deprecated @@ -39,7 +40,8 @@ check_memory, check_non_negative, _num_samples, - check_scalar) + check_scalar, + _check_sample_weight) import sklearn from sklearn.exceptions import NotFittedError @@ -853,3 +855,40 @@ def test_check_scalar_invalid(x, target_name, target_type, min_val, max_val, min_val=min_val, max_val=max_val) assert str(raised_error.value) == str(err_msg) assert type(raised_error.value) == type(err_msg) + + +def test_check_sample_weight(): + # check array order + sample_weight = np.ones(10)[::2] + assert not sample_weight.flags["C_CONTIGUOUS"] + sample_weight = _check_sample_weight(sample_weight, X=np.ones((5, 1))) + assert sample_weight.flags["C_CONTIGUOUS"] + + # check None input + sample_weight = _check_sample_weight(None, X=np.ones((5, 2))) + assert_allclose(sample_weight, np.ones(5)) + + # check numbers input + sample_weight = _check_sample_weight(2.0, X=np.ones((5, 2))) + assert_allclose(sample_weight, 2 * np.ones(5)) + + # check wrong number of dimensions + with pytest.raises(ValueError, + match="Sample weights must be 1D array or scalar"): + _check_sample_weight(np.ones((2, 4)), X=np.ones((2, 2))) + + # check incorrect n_samples + msg = r"sample_weight.shape == $4,$, expected $2,$!" + with pytest.raises(ValueError, match=msg): + _check_sample_weight(np.ones(4), X=np.ones((2, 2))) + + # float32 dtype is preserved + X = np.ones((5, 2)) + sample_weight = np.ones(5, dtype=np.float32) + sample_weight = _check_sample_weight(sample_weight, X) + assert sample_weight.dtype == np.float32 + + # int dtype will be converted to float64 instead + X = np.ones((5, 2), dtype=np.int) + sample_weight = _check_sample_weight(None, X, dtype=X.dtype) + assert sample_weight.dtype == np.float64

[ { "components": [ { "doc": "Set sample_weight if None, and check for correct dtype", "lines": [ 167, 179 ], "name": "_check_normalize_sample_weight", "signature": "def _check_normalize_sample_weight(sample_weight, X):", "type": "function"...

[ "sklearn/cluster/tests/test_k_means.py::test_kmeans_results[float32-dense-full]", "sklearn/cluster/tests/test_k_means.py::test_kmeans_results[float32-dense-elkan]", "sklearn/cluster/tests/test_k_means.py::test_kmeans_results[float32-sparse-full]", "sklearn/cluster/tests/test_k_means.py::test_kmeans_results[fl...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> MAINT Common sample_weight validation This implements a helper function for sample weight validation, and uses it consistently across the code base when applicable. Currently it's only applied to estimators (particularly in linear models and SVM) that already had some form of sample weight validation. It the future it might be worthwhile to add it to estimators that don't currently validate sample weights. It is a pre-requisite for optionally enforcing positive sample weights (https://github.com/scikit-learn/scikit-learn/issues/12464) Also somewhat related to https://github.com/scikit-learn/scikit-learn/pull/14286 and https://github.com/scikit-learn/scikit-learn/pull/14294 The main motivation is to avoid implementing this yet another time for GLMs in https://github.com/scikit-learn/scikit-learn/pull/14300 Any thought on this @glemaitre , since you were looking into related issues lately? ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/cluster/k_means_.py] (definition of _check_normalize_sample_weight:) def _check_normalize_sample_weight(sample_weight, X): """Set sample_weight if None, and check for correct dtype""" [end of new definitions in sklearn/cluster/k_means_.py] [start of new definitions in sklearn/utils/validation.py] (definition of _check_sample_weight:) def _check_sample_weight(sample_weight, X, dtype=None): """Validate sample weights. Parameters ---------- sample_weight : {ndarray, Number or None}, shape (n_samples,) Input sample weights. X : nd-array, list or sparse matrix Input data. dtype: dtype dtype of the validated `sample_weight`. If None, and the input `sample_weight` is an array, the dtype of the input is preserved; otherwise an array with the default numpy dtype is be allocated. If `dtype` is not one of `float32`, `float64`, `None`, the output will be of dtype `float64`. Returns ------- sample_weight : ndarray, shape (n_samples,) Validated sample weight. It is guaranteed to be "C" contiguous.""" [end of new definitions in sklearn/utils/validation.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c96e0958da46ebef482a4084cdda3285d5f5ad23

sympy__sympy-17174

17,174

sympy/sympy

1.5

8ca4a683d58ac1f61cfd2e4dacf7f58b9c0fefab

2019-07-11T16:16:07Z

diff --git a/sympy/stats/__init__.py b/sympy/stats/__init__.py index 6ae2ce1a961f..0527237d119a 100644 --- a/sympy/stats/__init__.py +++ b/sympy/stats/__init__.py @@ -94,6 +94,17 @@ ) __all__.extend(stochastic_process_types.__all__) +from . import random_matrix_models +from .random_matrix_models import ( + GaussianEnsemble, + GaussianUnitaryEnsemble, + GaussianOrthogonalEnsemble, + GaussianSymplecticEnsemble, + joint_eigen_distribution, + level_spacing_distribution +) +__all__.extend(random_matrix_models.__all__) + from . import symbolic_probability from .symbolic_probability import Probability, Expectation, Variance, Covariance __all__.extend(symbolic_probability.__all__) diff --git a/sympy/stats/random_matrix.py b/sympy/stats/random_matrix.py new file mode 100644 index 000000000000..126f6a322315 --- /dev/null +++ b/sympy/stats/random_matrix.py @@ -0,0 +1,24 @@ +from __future__ import print_function, division + +from sympy import Basic, MatrixSymbol +from sympy.stats.rv import PSpace, _symbol_converter, RandomMatrixSymbol + +class RandomMatrixPSpace(PSpace): + """ + Represents probability space for + random matrices. It contains the mechanics + for handling the API calls for random matrices. + """ + def __new__(cls, sym, model=None): + sym = _symbol_converter(sym) + return Basic.__new__(cls, sym, model) + + model = property(lambda self: self.args[1]) + + def compute_density(self, expr, *args): + rms = expr.atoms(RandomMatrixSymbol) + if len(rms) > 2 or (not isinstance(expr, RandomMatrixSymbol)): + raise NotImplementedError("Currently, no algorithm has been " + "implemented to handle general expressions containing " + "multiple random matrices.") + return self.model.density(expr) diff --git a/sympy/stats/random_matrix_models.py b/sympy/stats/random_matrix_models.py new file mode 100644 index 000000000000..277e20eecf47 --- /dev/null +++ b/sympy/stats/random_matrix_models.py @@ -0,0 +1,245 @@ +from __future__ import print_function, division + +from sympy import (Basic, exp, pi, Lambda, Trace, S, MatrixSymbol, Integral, + gamma, Product, Dummy, Sum, Abs, IndexedBase) +from sympy.core.sympify import _sympify +from sympy.multipledispatch import dispatch +from sympy.stats.rv import _symbol_converter, Density, RandomMatrixSymbol +from sympy.stats.random_matrix import RandomMatrixPSpace +from sympy.tensor.array import ArrayComprehension + +__all__ = [ + 'GaussianEnsemble', + 'GaussianUnitaryEnsemble', + 'GaussianOrthogonalEnsemble', + 'GaussianSymplecticEnsemble', + 'joint_eigen_distribution', + 'level_spacing_distribution' +] + +class RandomMatrixEnsemble(Basic): + """ + Abstract class for random matrix ensembles. + It acts as an umbrella for all the ensembles + defined in sympy.stats.random_matrix_models. + """ + pass + +class GaussianEnsemble(RandomMatrixEnsemble): + """ + Abstract class for Gaussian ensembles. + Contains the properties common to all the + gaussian ensembles. + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Random_matrix#Gaussian_ensembles + .. [2] https://arxiv.org/pdf/1712.07903.pdf + """ + def __new__(cls, sym, dim=None): + sym, dim = _symbol_converter(sym), _sympify(dim) + if dim.is_integer == False: + raise ValueError("Dimension of the random matrices must be " + "integers, received %s instead."%(dim)) + self = Basic.__new__(cls, sym, dim) + rmp = RandomMatrixPSpace(sym, model=self) + return RandomMatrixSymbol(sym, dim, dim, pspace=rmp) + + symbol = property(lambda self: self.args[0]) + dimension = property(lambda self: self.args[1]) + + def density(self, expr): + return Density(expr) + + def _compute_normalization_constant(self, beta, n): + """ + Helper function for computing normalization + constant for joint probability density of eigen + values of Gaussian ensembles. + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Selberg_integral#Mehta's_integral + """ + n = S(n) + prod_term = lambda j: gamma(1 + beta*S(j)/2)/gamma(S(1) + beta/S(2)) + j = Dummy('j', integer=True, positive=True) + term1 = Product(prod_term(j), (j, 1, n)).doit() + term2 = (2/(beta*n))**(beta*n*(n - 1)/4 + n/2) + term3 = (2*pi)**(n/2) + return term1 * term2 * term3 + + def _compute_joint_eigen_dsitribution(self, beta): + """ + Helper function for computing the joint + probability distribution of eigen values + of the random matrix. + """ + n = self.dimension + Zbn = self._compute_normalization_constant(beta, n) + l = IndexedBase('l') + i = Dummy('i', integer=True, positive=True) + j = Dummy('j', integer=True, positive=True) + k = Dummy('k', integer=True, positive=True) + term1 = exp((-S(n)/2) * Sum(l[k]**2, (k, 1, n)).doit()) + sub_term = Lambda(i, Product(Abs(l[j] - l[i])**beta, (j, i + 1, n))) + term2 = Product(sub_term(i).doit(), (i, 1, n - 1)).doit() + syms = ArrayComprehension(l[k], (k, 1, n)).doit() + return Lambda(syms, (term1 * term2)/Zbn) + +class GaussianUnitaryEnsemble(GaussianEnsemble): + """ + Represents Gaussian Unitary Ensembles. + + Examples + ======== + + >>> from sympy.stats import GaussianUnitaryEnsemble as GUE, density + >>> G = GUE('U', 2) + >>> density(G) + Lambda(H, exp(-Trace(H**2))/(2*pi**2)) + """ + @property + def normalization_constant(self): + n = self.dimension + return 2**(S(n)/2) * pi**(S(n**2)/2) + + def density(self, expr): + n, ZGUE = self.dimension, self.normalization_constant + h_pspace = RandomMatrixPSpace('P', model=self) + H = RandomMatrixSymbol('H', n, n, pspace=h_pspace) + return Lambda(H, exp(-S(n)/2 * Trace(H**2))/ZGUE) + + def joint_eigen_distribution(self): + return self._compute_joint_eigen_dsitribution(2) + + def level_spacing_distribution(self): + s = Dummy('s') + f = (32/pi**2)*(s**2)*exp((-4/pi)*s**2) + return Lambda(s, f) + +class GaussianOrthogonalEnsemble(GaussianEnsemble): + """ + Represents Gaussian Orthogonal Ensembles. + + Examples + ======== + + >>> from sympy.stats import GaussianOrthogonalEnsemble as GOE, density + >>> G = GOE('U', 2) + >>> density(G) + Lambda(H, exp(-Trace(H**2)/2)/Integral(exp(-Trace(_H**2)/2), _H)) + """ + @property + def normalization_constant(self): + n = self.dimension + _H = MatrixSymbol('_H', n, n) + return Integral(exp(-S(n)/4 * Trace(_H**2))) + + def density(self, expr): + n, ZGOE = self.dimension, self.normalization_constant + h_pspace = RandomMatrixPSpace('P', model=self) + H = RandomMatrixSymbol('H', n, n, pspace=h_pspace) + return Lambda(H, exp(-S(n)/4 * Trace(H**2))/ZGOE) + + def joint_eigen_distribution(self): + return self._compute_joint_eigen_dsitribution(1) + + def level_spacing_distribution(self): + s = Dummy('s') + f = (pi/2)*s*exp((-pi/4)*s**2) + return Lambda(s, f) + +class GaussianSymplecticEnsemble(GaussianEnsemble): + """ + Represents Gaussian Symplectic Ensembles. + + Examples + ======== + + >>> from sympy.stats import GaussianSymplecticEnsemble as GSE, density + >>> G = GSE('U', 2) + >>> density(G) + Lambda(H, exp(-2*Trace(H**2))/Integral(exp(-2*Trace(_H**2)), _H)) + """ + @property + def normalization_constant(self): + n = self.dimension + _H = MatrixSymbol('_H', n, n) + return Integral(exp(-S(n) * Trace(_H**2))) + + def density(self, expr): + n, ZGSE = self.dimension, self.normalization_constant + h_pspace = RandomMatrixPSpace('P', model=self) + H = RandomMatrixSymbol('H', n, n, pspace=h_pspace) + return Lambda(H, exp(-S(n) * Trace(H**2))/ZGSE) + + def joint_eigen_distribution(self): + return self._compute_joint_eigen_dsitribution(4) + + def level_spacing_distribution(self): + s = Dummy('s') + f = ((S(2)**18)/((S(3)**6)*(pi**3)))*(s**4)*exp((-64/(9*pi))*s**2) + return Lambda(s, f) + +@dispatch(RandomMatrixSymbol) +def joint_eigen_distribution(mat): + """ + For obtaining joint probability distribution + of eigen values of random matrix. + + Parameters + ========== + + mat: RandomMatrixSymbol + The matrix symbol whose eigen values are to be considered. + + Returns + ======= + + Lambda + + Examples + ======== + + >>> from sympy.stats import GaussianUnitaryEnsemble as GUE + >>> from sympy.stats import joint_eigen_distribution + >>> U = GUE('U', 2) + >>> joint_eigen_dsitribution(U) + Lambda((l[1], l[2]), exp(-l[1]**2 - l[2]**2)*Product(Abs(l[_i] - l[_j])**2, (_j, _i + 1, 2), (_i, 1, 1))/pi) + """ + return mat.pspace.model.joint_eigen_distribution() + +def level_spacing_distribution(mat): + """ + For obtaining distribution of level spacings. + + Parameters + ========== + + mat: RandomMatrixSymbol + The random matrix symbol whose eigen values are + to be considered for finding the level spacings. + + Returns + ======= + + Lambda + + Examples + ======== + + >>> from sympy.stats import GaussianUnitaryEnsemble as GUE + >>> from sympy.stats import level_spacing_distribution + >>> U = GUE('U', 2) + >>> level_spacing_distribution(U) + Lambda(_s, 32*_s**2*exp(-4*_s**2/pi)/pi**2) + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Random_matrix#Distribution_of_level_spacings + """ + return mat.pspace.model.level_spacing_distribution() diff --git a/sympy/stats/rv.py b/sympy/stats/rv.py index 43250c1a4044..7c5e6f464307 100644 --- a/sympy/stats/rv.py +++ b/sympy/stats/rv.py @@ -17,9 +17,10 @@ from sympy import (Basic, S, Expr, Symbol, Tuple, And, Add, Eq, lambdify, Equality, Lambda, sympify, Dummy, Ne, KroneckerDelta, - DiracDelta, Mul, Indexed, Function) + DiracDelta, Mul, Indexed, MatrixSymbol, Function) from sympy.core.compatibility import string_types from sympy.core.relational import Relational +from sympy.core.sympify import _sympify from sympy.logic.boolalg import Boolean from sympy.sets.sets import FiniteSet, ProductSet, Intersection from sympy.solvers.solveset import solveset @@ -289,6 +290,16 @@ def key(self): elif isinstance(self.symbol, Function): return self.symbol.args[0] +class RandomMatrixSymbol(MatrixSymbol): + def __new__(cls, symbol, n, m, pspace=None): + from sympy.stats.random_matrix import RandomMatrixPSpace + n, m = _sympify(n), _sympify(m) + symbol = _symbol_converter(symbol) + return Basic.__new__(cls, symbol, n, m, pspace) + + symbol = property(lambda self: self.args[0]) + pspace = property(lambda self: self.args[3]) + class ProductPSpace(PSpace): """ Abstract class for representing probability spaces with multiple random @@ -545,6 +556,10 @@ def pspace(expr): expr = sympify(expr) if isinstance(expr, RandomSymbol) and expr.pspace is not None: return expr.pspace + if expr.has(RandomMatrixSymbol): + rm = list(expr.atoms(RandomMatrixSymbol))[0] + return rm.pspace + rvs = random_symbols(expr) if not rvs: raise ValueError("Expression containing Random Variable expected, not %s" % (expr)) @@ -803,7 +818,10 @@ def condition(self): def doit(self, evaluate=True, **kwargs): from sympy.stats.joint_rv import JointPSpace from sympy.stats.frv import SingleFiniteDistribution + from sympy.stats.random_matrix_models import RandomMatrixPSpace expr, condition = self.expr, self.condition + if _sympify(expr).has(RandomMatrixSymbol): + return pspace(expr).compute_density(expr) if isinstance(expr, SingleFiniteDistribution): return expr.dict if condition is not None:

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index a4ac9ff6f349..d28040d6b2e7 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1563,6 +1563,12 @@ def test_sympy__stats__rv__RandomIndexedSymbol(): X = DiscreteMarkovChain("X") assert _test_args(RandomIndexedSymbol(X[0].symbol, pspace(X[0]))) +def test_sympy__stats__rv__RandomMatrixSymbol(): + from sympy.stats.rv import RandomMatrixSymbol + from sympy.stats.random_matrix import RandomMatrixPSpace + pspace = RandomMatrixPSpace('P') + assert _test_args(RandomMatrixSymbol('M', 3, 3, pspace)) + def test_sympy__stats__stochastic_process__StochasticPSpace(): from sympy.stats.stochastic_process import StochasticPSpace from sympy.stats.stochastic_process_types import StochasticProcess @@ -1613,6 +1619,31 @@ def test_sympy__stats__stochastic_process_types__ContinuousMarkovChain(): from sympy import MatrixSymbol assert _test_args(ContinuousMarkovChain("Y", [0, 1, 2], MatrixSymbol('T', 3, 3))) +def test_sympy__stats__random_matrix__RandomMatrixPSpace(): + from sympy.stats.random_matrix import RandomMatrixPSpace + from sympy.stats.random_matrix_models import RandomMatrixEnsemble + assert _test_args(RandomMatrixPSpace('P', RandomMatrixEnsemble())) + +def test_sympy__stats__random_matrix_models__RandomMatrixEnsemble(): + from sympy.stats.random_matrix_models import RandomMatrixEnsemble + assert _test_args(RandomMatrixEnsemble()) + +def test_sympy__stats__random_matrix_models__GaussianEnsemble(): + from sympy.stats.random_matrix_models import GaussianEnsemble + assert _test_args(GaussianEnsemble('G', 3)) + +def test_sympy__stats__random_matrix_models__GaussianUnitaryEnsemble(): + from sympy.stats import GaussianUnitaryEnsemble + assert _test_args(GaussianUnitaryEnsemble('U', 3)) + +def test_sympy__stats__random_matrix_models__GaussianOrthogonalEnsemble(): + from sympy.stats import GaussianOrthogonalEnsemble + assert _test_args(GaussianOrthogonalEnsemble('U', 3)) + +def test_sympy__stats__random_matrix_models__GaussianSymplecticEnsemble(): + from sympy.stats import GaussianSymplecticEnsemble + assert _test_args(GaussianSymplecticEnsemble('U', 3)) + def test_sympy__core__symbol__Dummy(): from sympy.core.symbol import Dummy assert _test_args(Dummy('t')) diff --git a/sympy/stats/tests/test_random_matrix.py b/sympy/stats/tests/test_random_matrix.py new file mode 100644 index 000000000000..2984692fa735 --- /dev/null +++ b/sympy/stats/tests/test_random_matrix.py @@ -0,0 +1,60 @@ +from sympy import (sqrt, exp, Trace, pi, S, Integral, MatrixSymbol, Lambda, + Dummy, Product, Sum, Abs, IndexedBase) +from sympy.stats import (GaussianUnitaryEnsemble as GUE, density, + GaussianOrthogonalEnsemble as GOE, + GaussianSymplecticEnsemble as GSE, + joint_eigen_distribution, + level_spacing_distribution) +from sympy.stats.rv import RandomMatrixSymbol, Density +from sympy.stats.random_matrix_models import GaussianEnsemble +from sympy.utilities.pytest import raises + +def test_GaussianEnsemble(): + G = GaussianEnsemble('G', 3) + assert density(G) == Density(G) + raises(ValueError, lambda: GaussianEnsemble('G', 3.5)) + +def test_GaussianUnitaryEnsemble(): + H = RandomMatrixSymbol('H', 3, 3) + G = GUE('U', 3) + assert density(G)(H) == sqrt(2)*exp(-3*Trace(H**2)/2)/(4*pi**(S(9)/2)) + i, j = (Dummy('i', integer=True, positive=True), + Dummy('j', integer=True, positive=True)) + l = IndexedBase('l') + assert joint_eigen_distribution(G).dummy_eq( + Lambda((l[1], l[2], l[3]), + 27*sqrt(6)*exp(-3*(l[1]**2)/2 - 3*(l[2]**2)/2 - 3*(l[3]**2)/2)* + Product(Abs(l[i] - l[j])**2, (j, i + 1, 3), (i, 1, 2))/(16*pi**(S(3)/2)))) + s = Dummy('s') + assert level_spacing_distribution(G).dummy_eq(Lambda(s, 32*s**2*exp(-4*s**2/pi)/pi**2)) + + +def test_GaussianOrthogonalEnsemble(): + H = RandomMatrixSymbol('H', 3, 3) + _H = MatrixSymbol('_H', 3, 3) + G = GOE('O', 3) + assert density(G)(H) == exp(-3*Trace(H**2)/4)/Integral(exp(-3*Trace(_H**2)/4), _H) + i, j = (Dummy('i', integer=True, positive=True), + Dummy('j', integer=True, positive=True)) + l = IndexedBase('l') + assert joint_eigen_distribution(G).dummy_eq( + Lambda((l[1], l[2], l[3]), + 9*sqrt(2)*exp(-3*l[1]**2/2 - 3*l[2]**2/2 - 3*l[3]**2/2)* + Product(Abs(l[i] - l[j]), (j, i + 1, 3), (i, 1, 2))/(32*pi))) + s = Dummy('s') + assert level_spacing_distribution(G).dummy_eq(Lambda(s, s*pi*exp(-s**2*pi/4)/2)) + +def test_GaussianSymplecticEnsemble(): + H = RandomMatrixSymbol('H', 3, 3) + _H = MatrixSymbol('_H', 3, 3) + G = GSE('O', 3) + assert density(G)(H) == exp(-3*Trace(H**2))/Integral(exp(-3*Trace(_H**2)), _H) + i, j = (Dummy('i', integer=True, positive=True), + Dummy('j', integer=True, positive=True)) + l = IndexedBase('l') + assert joint_eigen_distribution(G).dummy_eq( + Lambda((l[1], l[2], l[3]), + 162*sqrt(3)*exp(-3*l[1]**2/2 - 3*l[2]**2/2 - 3*l[3]**2/2)* + Product(Abs(l[i] - l[j])**4, (j, i + 1, 3), (i, 1, 2))/(5*pi**(S(3)/2)))) + s = Dummy('s') + assert level_spacing_distribution(G).dummy_eq(Lambda(s, S(262144)*s**4*exp(-64*s**2/(9*pi))/(729*pi**3)))

[ { "components": [ { "doc": "Represents probability space for\nrandom matrices. It contains the mechanics\nfor handling the API calls for random matrices.", "lines": [ 6, 24 ], "name": "RandomMatrixPSpace", "signature": "class RandomMatrixPSpace(P...

[ "test_sympy__stats__rv__RandomMatrixSymbol", "test_sympy__stats__random_matrix__RandomMatrixPSpace", "test_sympy__stats__random_matrix_models__RandomMatrixEnsemble", "test_sympy__stats__random_matrix_models__GaussianEnsemble", "test_sympy__stats__random_matrix_models__GaussianUnitaryEnsemble", "test_sympy...

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added random matrices(Gaussian Ensembles only)  #### References to other Issues or PRs  [1] https://github.com/sympy/sympy/issues/17039 #### Brief description of what is fixed or changed I have added framework random matrices. #### Other comments This is a work in progress. The first commit depicts how the framework for random matrices will look like. More features will added in the upcoming updates. #### Release Notes   * stats * Random matrices have been added to `sympy.stats`  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/random_matrix.py] (definition of RandomMatrixPSpace:) class RandomMatrixPSpace(PSpace): """Represents probability space for random matrices. It contains the mechanics for handling the API calls for random matrices.""" (definition of RandomMatrixPSpace.__new__:) def __new__(cls, sym, model=None): (definition of RandomMatrixPSpace.compute_density:) def compute_density(self, expr, *args): [end of new definitions in sympy/stats/random_matrix.py] [start of new definitions in sympy/stats/random_matrix_models.py] (definition of RandomMatrixEnsemble:) class RandomMatrixEnsemble(Basic): """Abstract class for random matrix ensembles. It acts as an umbrella for all the ensembles defined in sympy.stats.random_matrix_models.""" (definition of GaussianEnsemble:) class GaussianEnsemble(RandomMatrixEnsemble): """Abstract class for Gaussian ensembles. Contains the properties common to all the gaussian ensembles. References ========== .. [1] https://en.wikipedia.org/wiki/Random_matrix#Gaussian_ensembles .. [2] https://arxiv.org/pdf/1712.07903.pdf""" (definition of GaussianEnsemble.__new__:) def __new__(cls, sym, dim=None): (definition of GaussianEnsemble.density:) def density(self, expr): (definition of GaussianEnsemble._compute_normalization_constant:) def _compute_normalization_constant(self, beta, n): """Helper function for computing normalization constant for joint probability density of eigen values of Gaussian ensembles. References ========== .. [1] https://en.wikipedia.org/wiki/Selberg_integral#Mehta's_integral""" (definition of GaussianEnsemble._compute_joint_eigen_dsitribution:) def _compute_joint_eigen_dsitribution(self, beta): """Helper function for computing the joint probability distribution of eigen values of the random matrix.""" (definition of GaussianUnitaryEnsemble:) class GaussianUnitaryEnsemble(GaussianEnsemble): """Represents Gaussian Unitary Ensembles. Examples ======== >>> from sympy.stats import GaussianUnitaryEnsemble as GUE, density >>> G = GUE('U', 2) >>> density(G) Lambda(H, exp(-Trace(H**2))/(2*pi**2))""" (definition of GaussianUnitaryEnsemble.normalization_constant:) def normalization_constant(self): (definition of GaussianUnitaryEnsemble.density:) def density(self, expr): (definition of GaussianUnitaryEnsemble.joint_eigen_distribution:) def joint_eigen_distribution(self): (definition of GaussianUnitaryEnsemble.level_spacing_distribution:) def level_spacing_distribution(self): (definition of GaussianOrthogonalEnsemble:) class GaussianOrthogonalEnsemble(GaussianEnsemble): """Represents Gaussian Orthogonal Ensembles. Examples ======== >>> from sympy.stats import GaussianOrthogonalEnsemble as GOE, density >>> G = GOE('U', 2) >>> density(G) Lambda(H, exp(-Trace(H**2)/2)/Integral(exp(-Trace(_H**2)/2), _H))""" (definition of GaussianOrthogonalEnsemble.normalization_constant:) def normalization_constant(self): (definition of GaussianOrthogonalEnsemble.density:) def density(self, expr): (definition of GaussianOrthogonalEnsemble.joint_eigen_distribution:) def joint_eigen_distribution(self): (definition of GaussianOrthogonalEnsemble.level_spacing_distribution:) def level_spacing_distribution(self): (definition of GaussianSymplecticEnsemble:) class GaussianSymplecticEnsemble(GaussianEnsemble): """Represents Gaussian Symplectic Ensembles. Examples ======== >>> from sympy.stats import GaussianSymplecticEnsemble as GSE, density >>> G = GSE('U', 2) >>> density(G) Lambda(H, exp(-2*Trace(H**2))/Integral(exp(-2*Trace(_H**2)), _H))""" (definition of GaussianSymplecticEnsemble.normalization_constant:) def normalization_constant(self): (definition of GaussianSymplecticEnsemble.density:) def density(self, expr): (definition of GaussianSymplecticEnsemble.joint_eigen_distribution:) def joint_eigen_distribution(self): (definition of GaussianSymplecticEnsemble.level_spacing_distribution:) def level_spacing_distribution(self): (definition of joint_eigen_distribution:) def joint_eigen_distribution(mat): """For obtaining joint probability distribution of eigen values of random matrix. Parameters ========== mat: RandomMatrixSymbol The matrix symbol whose eigen values are to be considered. Returns ======= Lambda Examples ======== >>> from sympy.stats import GaussianUnitaryEnsemble as GUE >>> from sympy.stats import joint_eigen_distribution >>> U = GUE('U', 2) >>> joint_eigen_dsitribution(U) Lambda((l[1], l[2]), exp(-l[1]**2 - l[2]**2)*Product(Abs(l[_i] - l[_j])**2, (_j, _i + 1, 2), (_i, 1, 1))/pi)""" (definition of level_spacing_distribution:) def level_spacing_distribution(mat): """For obtaining distribution of level spacings. Parameters ========== mat: RandomMatrixSymbol The random matrix symbol whose eigen values are to be considered for finding the level spacings. Returns ======= Lambda Examples ======== >>> from sympy.stats import GaussianUnitaryEnsemble as GUE >>> from sympy.stats import level_spacing_distribution >>> U = GUE('U', 2) >>> level_spacing_distribution(U) Lambda(_s, 32*_s**2*exp(-4*_s**2/pi)/pi**2) References ========== .. [1] https://en.wikipedia.org/wiki/Random_matrix#Distribution_of_level_spacings""" [end of new definitions in sympy/stats/random_matrix_models.py] [start of new definitions in sympy/stats/rv.py] (definition of RandomMatrixSymbol:) class RandomMatrixSymbol(MatrixSymbol): (definition of RandomMatrixSymbol.__new__:) def __new__(cls, symbol, n, m, pspace=None): [end of new definitions in sympy/stats/rv.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

scrapy__scrapy-3862

3,862

scrapy/scrapy

null

ae4eab9843752e7cf75420a5d4f4fa58f8da8e50

2019-07-09T18:24:49Z

diff --git a/docs/topics/developer-tools.rst b/docs/topics/developer-tools.rst index 82857c9da90..dcf8af36523 100644 --- a/docs/topics/developer-tools.rst +++ b/docs/topics/developer-tools.rst @@ -252,9 +252,33 @@ If the handy ``has_next`` element is ``true`` (try loading `quotes.toscrape.com/api/quotes?page=10`_ in your browser or a page-number greater than 10), we increment the ``page`` attribute and ``yield`` a new request, inserting the incremented page-number -into our ``url``. +into our ``url``. -You can see that with a few inspections in the `Network`-tool we +.. _requests-from-curl: + +In more complex websites, it could be difficult to easily reproduce the +requests, as we could need to add ``headers`` or ``cookies`` to make it work. +In those cases you can export the requests in `cURL <https://curl.haxx.se/>`_ +format, by right-clicking on each of them in the network tool and using the +:meth:`~scrapy.http.Request.from_curl()` method to generate an equivalent +request:: + + from scrapy import Request + + request = Request.from_curl( + "curl 'http://quotes.toscrape.com/api/quotes?page=1' -H 'User-Agent: Mozil" + "la/5.0 (X11; Linux x86_64; rv:67.0) Gecko/20100101 Firefox/67.0' -H 'Acce" + "pt: */*' -H 'Accept-Language: ca,en-US;q=0.7,en;q=0.3' --compressed -H 'X" + "-Requested-With: XMLHttpRequest' -H 'Proxy-Authorization: Basic QFRLLTAzM" + "zEwZTAxLTk5MWUtNDFiNC1iZWRmLTJjNGI4M2ZiNDBmNDpAVEstMDMzMTBlMDEtOTkxZS00MW" + "I0LWJlZGYtMmM0YjgzZmI0MGY0' -H 'Connection: keep-alive' -H 'Referer: http" + "://quotes.toscrape.com/scroll' -H 'Cache-Control: max-age=0'") + +Alternatively, if you want to know the arguments needed to recreate that +request you can use the :func:`scrapy.utils.curl.curl_to_request_kwargs` +function to get a dictionary with the equivalent arguments. + +As you can see, with a few inspections in the `Network`-tool we were able to easily replicate the dynamic requests of the scrolling functionality of the page. Crawling dynamic pages can be quite daunting and pages can be very complex, but it (mostly) boils down @@ -262,7 +286,7 @@ to identifying the correct request and replicating it in your spider. .. _Developer Tools: https://en.wikipedia.org/wiki/Web_development_tools .. _quotes.toscrape.com: http://quotes.toscrape.com -.. _quotes.toscrape.com/scroll: quotes.toscrape.com/scroll/ +.. _quotes.toscrape.com/scroll: http://quotes.toscrape.com/scroll .. _quotes.toscrape.com/api/quotes?page=10: http://quotes.toscrape.com/api/quotes?page=10 .. _has-class-extension: https://parsel.readthedocs.io/en/latest/usage.html#other-xpath-extensions diff --git a/docs/topics/dynamic-content.rst b/docs/topics/dynamic-content.rst index 8b5dacf5607..8334ddcecd3 100644 --- a/docs/topics/dynamic-content.rst +++ b/docs/topics/dynamic-content.rst @@ -85,6 +85,13 @@ It might be enough to yield a :class:`~scrapy.http.Request` with the same HTTP method and URL. However, you may also need to reproduce the body, headers and form parameters (see :class:`~scrapy.http.FormRequest`) of that request. +As all major browsers allow to export the requests in `cURL +<https://curl.haxx.se/>`_ format, Scrapy incorporates the method +:meth:`~scrapy.http.Request.from_curl()` to generate an equivalent +:class:`~scrapy.http.Request` from a cURL command. To get more information +visit :ref:`request from curl <requests-from-curl>` inside the network +tool section. + Once you get the expected response, you can :ref:`extract the desired data from it <topics-handling-response-formats>`. diff --git a/docs/topics/request-response.rst b/docs/topics/request-response.rst index 4e81ce878ef..9a5c65b0d18 100644 --- a/docs/topics/request-response.rst +++ b/docs/topics/request-response.rst @@ -194,6 +194,8 @@ Request objects copied by default (unless new values are given as arguments). See also :ref:`topics-request-response-ref-request-callback-arguments`. + .. automethod:: from_curl + .. _topics-request-response-ref-request-callback-arguments: Passing additional data to callback functions diff --git a/scrapy/http/request/__init__.py b/scrapy/http/request/__init__.py index f5935c4ef63..d09eaf8497f 100644 --- a/scrapy/http/request/__init__.py +++ b/scrapy/http/request/__init__.py @@ -12,6 +12,7 @@ from scrapy.utils.trackref import object_ref from scrapy.utils.url import escape_ajax from scrapy.http.common import obsolete_setter +from scrapy.utils.curl import curl_to_request_kwargs class Request(object_ref): @@ -103,3 +104,34 @@ def replace(self, *args, **kwargs): kwargs.setdefault(x, getattr(self, x)) cls = kwargs.pop('cls', self.__class__) return cls(*args, **kwargs) + + @classmethod + def from_curl(cls, curl_command, ignore_unknown_options=True, **kwargs): + """Create a Request object from a string containing a `cURL + <https://curl.haxx.se/>`_ command. It populates the HTTP method, the + URL, the headers, the cookies and the body. It accepts the same + arguments as the :class:`Request` class, taking preference and + overriding the values of the same arguments contained in the cURL + command. + + Unrecognized options are ignored by default. To raise an error when + finding unknown options call this method by passing + ``ignore_unknown_options=False``. + + .. caution:: Using :meth:`from_curl` from :class:`~scrapy.http.Request` + subclasses, such as :class:`~scrapy.http.JSONRequest`, or + :class:`~scrapy.http.XmlRpcRequest`, as well as having + :ref:`downloader middlewares <topics-downloader-middleware>` + and + :ref:`spider middlewares <topics-spider-middleware>` + enabled, such as + :class:`~scrapy.downloadermiddlewares.defaultheaders.DefaultHeadersMiddleware`, + :class:`~scrapy.downloadermiddlewares.useragent.UserAgentMiddleware`, + or + :class:`~scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware`, + may modify the :class:`~scrapy.http.Request` object. + + """ + request_kwargs = curl_to_request_kwargs(curl_command, ignore_unknown_options) + request_kwargs.update(kwargs) + return cls(**request_kwargs) diff --git a/scrapy/utils/curl.py b/scrapy/utils/curl.py new file mode 100644 index 00000000000..b3fd0a497ff --- /dev/null +++ b/scrapy/utils/curl.py @@ -0,0 +1,95 @@ +import argparse +import warnings +from shlex import split + +from six.moves.http_cookies import SimpleCookie +from six.moves.urllib.parse import urlparse +from six import string_types, iteritems +from w3lib.http import basic_auth_header + + +class CurlParser(argparse.ArgumentParser): + def error(self, message): + error_msg = \ + 'There was an error parsing the curl command: {}'.format(message) + raise ValueError(error_msg) + + +curl_parser = CurlParser() +curl_parser.add_argument('url') +curl_parser.add_argument('-H', '--header', dest='headers', action='append') +curl_parser.add_argument('-X', '--request', dest='method', default='get') +curl_parser.add_argument('-d', '--data', dest='data') +curl_parser.add_argument('-u', '--user', dest='auth') + + +safe_to_ignore_arguments = [ + ['--compressed'], + # `--compressed` argument is not safe to ignore, but it's included here + # because the `HttpCompressionMiddleware` is enabled by default + ['-s', '--silent'], + ['-v', '--verbose'], + ['-#', '--progress-bar'] +] + +for argument in safe_to_ignore_arguments: + curl_parser.add_argument(*argument, action='store_true') + + +def curl_to_request_kwargs(curl_command, ignore_unknown_options=True): + """Convert a cURL command syntax to Request kwargs. + + :param str curl_command: string containing the curl command + :param bool ignore_unknown_options: If true, only a warning is emitted when + cURL options are unknown. Otherwise raises an error. (default: True) + :return: dictionary of Request kwargs + """ + + curl_args = split(curl_command) + + if curl_args[0] != 'curl': + raise ValueError('A curl command must start with "curl"') + + parsed_args, argv = curl_parser.parse_known_args(curl_args[1:]) + + if argv: + msg = 'Unrecognized options: {}'.format(', '.join(argv)) + if ignore_unknown_options: + warnings.warn(msg) + else: + raise ValueError(msg) + + url = parsed_args.url + + # curl automatically prepends 'http' if the scheme is missing, but Request + # needs the scheme to work + parsed_url = urlparse(url) + if not parsed_url.scheme: + url = 'http://' + url + + result = {'method': parsed_args.method.upper(), 'url': url} + + headers = [] + cookies = {} + for header in parsed_args.headers or (): + name, val = header.split(':', 1) + name = name.strip() + val = val.strip() + if name.title() == 'Cookie': + for name, morsel in iteritems(SimpleCookie(val)): + cookies[name] = morsel.value + else: + headers.append((name, val)) + + if parsed_args.auth: + user, password = parsed_args.auth.split(':', 1) + headers.append(('Authorization', basic_auth_header(user, password))) + + if headers: + result['headers'] = headers + if cookies: + result['cookies'] = cookies + if parsed_args.data: + result['body'] = parsed_args.data + + return result

diff --git a/tests/test_http_request.py b/tests/test_http_request.py index 952e208de0a..60494d792e1 100644 --- a/tests/test_http_request.py +++ b/tests/test_http_request.py @@ -269,6 +269,82 @@ def a_function(): with self.assertRaises(TypeError): self.request_class('http://example.com', a_function, errback='a_function') + def test_from_curl(self): + # Note: more curated tests regarding curl conversion are in + # `test_utils_curl.py` + curl_command = ( + "curl 'http://httpbin.org/post' -X POST -H 'Cookie: _gauges_unique" + "_year=1; _gauges_unique=1; _gauges_unique_month=1; _gauges_unique" + "_hour=1; _gauges_unique_day=1' -H 'Origin: http://httpbin.org' -H" + " 'Accept-Encoding: gzip, deflate' -H 'Accept-Language: en-US,en;q" + "=0.9,ru;q=0.8,es;q=0.7' -H 'Upgrade-Insecure-Requests: 1' -H 'Use" + "r-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTM" + "L, like Gecko) Ubuntu Chromium/62.0.3202.75 Chrome/62.0.3202.75 S" + "afari/537.36' -H 'Content-Type: application /x-www-form-urlencode" + "d' -H 'Accept: text/html,application/xhtml+xml,application/xml;q=" + "0.9,image/webp,image/apng,*/*;q=0.8' -H 'Cache-Control: max-age=0" + "' -H 'Referer: http://httpbin.org/forms/post' -H 'Connection: kee" + "p-alive' --data 'custname=John+Smith&custtel=500&custemail=jsmith" + "%40example.org&size=small&topping=cheese&topping=onion&delivery=1" + "2%3A15&comments=' --compressed" + ) + r = self.request_class.from_curl(curl_command) + self.assertEqual(r.method, "POST") + self.assertEqual(r.url, "http://httpbin.org/post") + self.assertEqual(r.body, + b"custname=John+Smith&custtel=500&custemail=jsmith%40" + b"example.org&size=small&topping=cheese&topping=onion" + b"&delivery=12%3A15&comments=") + self.assertEqual(r.cookies, { + '_gauges_unique_year': '1', + '_gauges_unique': '1', + '_gauges_unique_month': '1', + '_gauges_unique_hour': '1', + '_gauges_unique_day': '1' + }) + self.assertEqual(r.headers, { + b'Origin': [b'http://httpbin.org'], + b'Accept-Encoding': [b'gzip, deflate'], + b'Accept-Language': [b'en-US,en;q=0.9,ru;q=0.8,es;q=0.7'], + b'Upgrade-Insecure-Requests': [b'1'], + b'User-Agent': [b'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.' + b'36 (KHTML, like Gecko) Ubuntu Chromium/62.0.3202' + b'.75 Chrome/62.0.3202.75 Safari/537.36'], + b'Content-Type': [b'application /x-www-form-urlencoded'], + b'Accept': [b'text/html,application/xhtml+xml,application/xml;q=0.' + b'9,image/webp,image/apng,*/*;q=0.8'], + b'Cache-Control': [b'max-age=0'], + b'Referer': [b'http://httpbin.org/forms/post'], + b'Connection': [b'keep-alive']}) + + def test_from_curl_with_kwargs(self): + r = self.request_class.from_curl( + 'curl -X PATCH "http://example.org"', + method="POST", + meta={'key': 'value'} + ) + self.assertEqual(r.method, "POST") + self.assertEqual(r.meta, {"key": "value"}) + + def test_from_curl_ignore_unknown_options(self): + # By default: it works and ignores the unknown options: --foo and -z + with warnings.catch_warnings(): # avoid warning when executing tests + warnings.simplefilter('ignore') + r = self.request_class.from_curl( + 'curl -X DELETE "http://example.org" --foo -z', + ) + self.assertEqual(r.method, "DELETE") + + # If `ignore_unknon_options` is set to `False` it raises an error with + # the unknown options: --foo and -z + self.assertRaises( + ValueError, + lambda: self.request_class.from_curl( + 'curl -X PATCH "http://example.org" --foo -z', + ignore_unknown_options=False, + ), + ) + class FormRequestTest(RequestTest): diff --git a/tests/test_utils_curl.py b/tests/test_utils_curl.py new file mode 100644 index 00000000000..c5655df7ee0 --- /dev/null +++ b/tests/test_utils_curl.py @@ -0,0 +1,211 @@ +import unittest +import warnings + +from six import assertRaisesRegex +from w3lib.http import basic_auth_header + +from scrapy import Request +from scrapy.utils.curl import curl_to_request_kwargs + + +class CurlToRequestKwargsTest(unittest.TestCase): + maxDiff = 5000 + + def _test_command(self, curl_command, expected_result): + result = curl_to_request_kwargs(curl_command) + self.assertEqual(result, expected_result) + try: + Request(**result) + except TypeError as e: + self.fail("Request kwargs are not correct {}".format(e)) + + def test_get(self): + curl_command = "curl http://example.org/" + expected_result = {"method": "GET", "url": "http://example.org/"} + self._test_command(curl_command, expected_result) + + def test_get_without_scheme(self): + curl_command = "curl www.example.org" + expected_result = {"method": "GET", "url": "http://www.example.org"} + self._test_command(curl_command, expected_result) + + def test_get_basic_auth(self): + curl_command = 'curl "https://api.test.com/" -u ' \ + '"some_username:some_password"' + expected_result = { + "method": "GET", + "url": "https://api.test.com/", + "headers": [ + ( + "Authorization", + basic_auth_header("some_username", "some_password") + ) + ], + } + self._test_command(curl_command, expected_result) + + def test_get_complex(self): + curl_command = ( + "curl 'http://httpbin.org/get' -H 'Accept-Encoding: gzip, deflate'" + " -H 'Accept-Language: en-US,en;q=0.9,ru;q=0.8,es;q=0.7' -H 'Upgra" + "de-Insecure-Requests: 1' -H 'User-Agent: Mozilla/5.0 (X11; Linux " + "x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Ubuntu Chromium/62" + ".0.3202.75 Chrome/62.0.3202.75 Safari/537.36' -H 'Accept: text/ht" + "ml,application/xhtml+xml,application/xml;q=0.9,image/webp,image/a" + "png,*/*;q=0.8' -H 'Referer: http://httpbin.org/' -H 'Cookie: _gau" + "ges_unique_year=1; _gauges_unique=1; _gauges_unique_month=1; _gau" + "ges_unique_hour=1; _gauges_unique_day=1' -H 'Connection: keep-ali" + "ve' --compressed" + ) + expected_result = { + "method": "GET", + "url": "http://httpbin.org/get", + "headers": [ + ("Accept-Encoding", "gzip, deflate"), + ("Accept-Language", "en-US,en;q=0.9,ru;q=0.8,es;q=0.7"), + ("Upgrade-Insecure-Requests", "1"), + ( + "User-Agent", + "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML" + ", like Gecko) Ubuntu Chromium/62.0.3202.75 Chrome/62.0.32" + "02.75 Safari/537.36", + ), + ( + "Accept", + "text/html,application/xhtml+xml,application/xml;q=0.9,ima" + "ge/webp,image/apng,*/*;q=0.8", + ), + ("Referer", "http://httpbin.org/"), + ("Connection", "keep-alive"), + ], + "cookies": { + '_gauges_unique_year': '1', + '_gauges_unique_hour': '1', + '_gauges_unique_day': '1', + '_gauges_unique': '1', + '_gauges_unique_month': '1' + }, + } + self._test_command(curl_command, expected_result) + + def test_post(self): + curl_command = ( + "curl 'http://httpbin.org/post' -X POST -H 'Cookie: _gauges_unique" + "_year=1; _gauges_unique=1; _gauges_unique_month=1; _gauges_unique" + "_hour=1; _gauges_unique_day=1' -H 'Origin: http://httpbin.org' -H" + " 'Accept-Encoding: gzip, deflate' -H 'Accept-Language: en-US,en;q" + "=0.9,ru;q=0.8,es;q=0.7' -H 'Upgrade-Insecure-Requests: 1' -H 'Use" + "r-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTM" + "L, like Gecko) Ubuntu Chromium/62.0.3202.75 Chrome/62.0.3202.75 S" + "afari/537.36' -H 'Content-Type: application/x-www-form-urlencoded" + "' -H 'Accept: text/html,application/xhtml+xml,application/xml;q=0" + ".9,image/webp,image/apng,*/*;q=0.8' -H 'Cache-Control: max-age=0'" + " -H 'Referer: http://httpbin.org/forms/post' -H 'Connection: keep" + "-alive' --data 'custname=John+Smith&custtel=500&custemail=jsmith%" + "40example.org&size=small&topping=cheese&topping=onion&delivery=12" + "%3A15&comments=' --compressed" + ) + expected_result = { + "method": "POST", + "url": "http://httpbin.org/post", + "body": "custname=John+Smith&custtel=500&custemail=jsmith%40exampl" + "e.org&size=small&topping=cheese&topping=onion&delivery=12" + "%3A15&comments=", + "cookies": { + '_gauges_unique_year': '1', + '_gauges_unique_hour': '1', + '_gauges_unique_day': '1', + '_gauges_unique': '1', + '_gauges_unique_month': '1' + }, + "headers": [ + ("Origin", "http://httpbin.org"), + ("Accept-Encoding", "gzip, deflate"), + ("Accept-Language", "en-US,en;q=0.9,ru;q=0.8,es;q=0.7"), + ("Upgrade-Insecure-Requests", "1"), + ( + "User-Agent", + "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML" + ", like Gecko) Ubuntu Chromium/62.0.3202.75 Chrome/62.0.32" + "02.75 Safari/537.36", + ), + ("Content-Type", "application/x-www-form-urlencoded"), + ( + "Accept", + "text/html,application/xhtml+xml,application/xml;q=0.9,ima" + "ge/webp,image/apng,*/*;q=0.8", + ), + ("Cache-Control", "max-age=0"), + ("Referer", "http://httpbin.org/forms/post"), + ("Connection", "keep-alive"), + ], + } + self._test_command(curl_command, expected_result) + + def test_patch(self): + curl_command = ( + 'curl "https://example.com/api/fake" -u "username:password" -H "Ac' + 'cept: application/vnd.go.cd.v4+json" -H "Content-Type: applicatio' + 'n/json" -X PATCH -d \'{"hostname": "agent02.example.com", "agent' + '_config_state": "Enabled", "resources": ["Java","Linux"], "enviro' + 'nments": ["Dev"]}\'' + ) + expected_result = { + "method": "PATCH", + "url": "https://example.com/api/fake", + "headers": [ + ("Accept", "application/vnd.go.cd.v4+json"), + ("Content-Type", "application/json"), + ("Authorization", basic_auth_header("username", "password")), + ], + "body": '{"hostname": "agent02.example.com", "agent_config_state"' + ': "Enabled", "resources": ["Java","Linux"], "environments' + '": ["Dev"]}', + } + self._test_command(curl_command, expected_result) + + def test_delete(self): + curl_command = 'curl -X "DELETE" https://www.url.com/page' + expected_result = { + "method": "DELETE", "url": "https://www.url.com/page" + } + self._test_command(curl_command, expected_result) + + def test_get_silent(self): + curl_command = 'curl --silent "www.example.com"' + expected_result = {"method": "GET", "url": "http://www.example.com"} + self.assertEqual(curl_to_request_kwargs(curl_command), expected_result) + + def test_too_few_arguments_error(self): + assertRaisesRegex( + self, + ValueError, + r"too few arguments|the following arguments are required:\s*url", + lambda: curl_to_request_kwargs("curl"), + ) + + def test_ignore_unknown_options(self): + # case 1: ignore_unknown_options=True: + with warnings.catch_warnings(): # avoid warning when executing tests + warnings.simplefilter('ignore') + curl_command = 'curl --bar --baz http://www.example.com' + expected_result = \ + {"method": "GET", "url": "http://www.example.com"} + self.assertEqual(curl_to_request_kwargs(curl_command), expected_result) + + # case 2: ignore_unknown_options=False (raise exception): + assertRaisesRegex( + self, + ValueError, + "Unrecognized options:.*--bar.*--baz", + lambda: curl_to_request_kwargs( + "curl --bar --baz http://www.example.com", + ignore_unknown_options=False + ), + ) + + def test_must_start_with_curl_error(self): + self.assertRaises( + ValueError, + lambda: curl_to_request_kwargs("carl -X POST http://example.org") + )

diff --git a/docs/topics/developer-tools.rst b/docs/topics/developer-tools.rst index 82857c9da90..dcf8af36523 100644 --- a/docs/topics/developer-tools.rst +++ b/docs/topics/developer-tools.rst @@ -252,9 +252,33 @@ If the handy ``has_next`` element is ``true`` (try loading `quotes.toscrape.com/api/quotes?page=10`_ in your browser or a page-number greater than 10), we increment the ``page`` attribute and ``yield`` a new request, inserting the incremented page-number -into our ``url``. +into our ``url``. -You can see that with a few inspections in the `Network`-tool we +.. _requests-from-curl: + +In more complex websites, it could be difficult to easily reproduce the +requests, as we could need to add ``headers`` or ``cookies`` to make it work. +In those cases you can export the requests in `cURL <https://curl.haxx.se/>`_ +format, by right-clicking on each of them in the network tool and using the +:meth:`~scrapy.http.Request.from_curl()` method to generate an equivalent +request:: + + from scrapy import Request + + request = Request.from_curl( + "curl 'http://quotes.toscrape.com/api/quotes?page=1' -H 'User-Agent: Mozil" + "la/5.0 (X11; Linux x86_64; rv:67.0) Gecko/20100101 Firefox/67.0' -H 'Acce" + "pt: */*' -H 'Accept-Language: ca,en-US;q=0.7,en;q=0.3' --compressed -H 'X" + "-Requested-With: XMLHttpRequest' -H 'Proxy-Authorization: Basic QFRLLTAzM" + "zEwZTAxLTk5MWUtNDFiNC1iZWRmLTJjNGI4M2ZiNDBmNDpAVEstMDMzMTBlMDEtOTkxZS00MW" + "I0LWJlZGYtMmM0YjgzZmI0MGY0' -H 'Connection: keep-alive' -H 'Referer: http" + "://quotes.toscrape.com/scroll' -H 'Cache-Control: max-age=0'") + +Alternatively, if you want to know the arguments needed to recreate that +request you can use the :func:`scrapy.utils.curl.curl_to_request_kwargs` +function to get a dictionary with the equivalent arguments. + +As you can see, with a few inspections in the `Network`-tool we were able to easily replicate the dynamic requests of the scrolling functionality of the page. Crawling dynamic pages can be quite daunting and pages can be very complex, but it (mostly) boils down @@ -262,7 +286,7 @@ to identifying the correct request and replicating it in your spider. .. _Developer Tools: https://en.wikipedia.org/wiki/Web_development_tools .. _quotes.toscrape.com: http://quotes.toscrape.com -.. _quotes.toscrape.com/scroll: quotes.toscrape.com/scroll/ +.. _quotes.toscrape.com/scroll: http://quotes.toscrape.com/scroll .. _quotes.toscrape.com/api/quotes?page=10: http://quotes.toscrape.com/api/quotes?page=10 .. _has-class-extension: https://parsel.readthedocs.io/en/latest/usage.html#other-xpath-extensions diff --git a/docs/topics/dynamic-content.rst b/docs/topics/dynamic-content.rst index 8b5dacf5607..8334ddcecd3 100644 --- a/docs/topics/dynamic-content.rst +++ b/docs/topics/dynamic-content.rst @@ -85,6 +85,13 @@ It might be enough to yield a :class:`~scrapy.http.Request` with the same HTTP method and URL. However, you may also need to reproduce the body, headers and form parameters (see :class:`~scrapy.http.FormRequest`) of that request. +As all major browsers allow to export the requests in `cURL +<https://curl.haxx.se/>`_ format, Scrapy incorporates the method +:meth:`~scrapy.http.Request.from_curl()` to generate an equivalent +:class:`~scrapy.http.Request` from a cURL command. To get more information +visit :ref:`request from curl <requests-from-curl>` inside the network +tool section. + Once you get the expected response, you can :ref:`extract the desired data from it <topics-handling-response-formats>`. diff --git a/docs/topics/request-response.rst b/docs/topics/request-response.rst index 4e81ce878ef..9a5c65b0d18 100644 --- a/docs/topics/request-response.rst +++ b/docs/topics/request-response.rst @@ -194,6 +194,8 @@ Request objects copied by default (unless new values are given as arguments). See also :ref:`topics-request-response-ref-request-callback-arguments`. + .. automethod:: from_curl + .. _topics-request-response-ref-request-callback-arguments: Passing additional data to callback functions

[ { "components": [ { "doc": "Create a Request object from a string containing a `cURL\n<https://curl.haxx.se/>`_ command. It populates the HTTP method, the\nURL, the headers, the cookies and the body. It accepts the same\narguments as the :class:`Request` class, taking preference and\noverriding th...

[ "tests/test_http_request.py::RequestTest::test_ajax_url", "tests/test_http_request.py::RequestTest::test_body", "tests/test_http_request.py::RequestTest::test_callback_is_callable", "tests/test_http_request.py::RequestTest::test_copy", "tests/test_http_request.py::RequestTest::test_copy_inherited_classes", ...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG+1] Create Request from curl command This is a WIP, but I open this PR to discuss how to implement this feature. Based on: https://github.com/scrapy/scrapy/pull/2985 (abandoned) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in scrapy/http/request/__init__.py] (definition of Request.from_curl:) def from_curl(cls, curl_command, ignore_unknown_options=True, **kwargs): """Create a Request object from a string containing a `cURL <https://curl.haxx.se/>`_ command. It populates the HTTP method, the URL, the headers, the cookies and the body. It accepts the same arguments as the :class:`Request` class, taking preference and overriding the values of the same arguments contained in the cURL command. Unrecognized options are ignored by default. To raise an error when finding unknown options call this method by passing ``ignore_unknown_options=False``. .. caution:: Using :meth:`from_curl` from :class:`~scrapy.http.Request` subclasses, such as :class:`~scrapy.http.JSONRequest`, or :class:`~scrapy.http.XmlRpcRequest`, as well as having :ref:`downloader middlewares <topics-downloader-middleware>` and :ref:`spider middlewares <topics-spider-middleware>` enabled, such as :class:`~scrapy.downloadermiddlewares.defaultheaders.DefaultHeadersMiddleware`, :class:`~scrapy.downloadermiddlewares.useragent.UserAgentMiddleware`, or :class:`~scrapy.downloadermiddlewares.httpcompression.HttpCompressionMiddleware`, may modify the :class:`~scrapy.http.Request` object.""" [end of new definitions in scrapy/http/request/__init__.py] [start of new definitions in scrapy/utils/curl.py] (definition of CurlParser:) class CurlParser(argparse.ArgumentParser): (definition of CurlParser.error:) def error(self, message): (definition of curl_to_request_kwargs:) def curl_to_request_kwargs(curl_command, ignore_unknown_options=True): """Convert a cURL command syntax to Request kwargs. :param str curl_command: string containing the curl command :param bool ignore_unknown_options: If true, only a warning is emitted when cURL options are unknown. Otherwise raises an error. (default: True) :return: dictionary of Request kwargs""" [end of new definitions in scrapy/utils/curl.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

57a5460529ff71c42e4d0381265b1b512b1eb09b

sympy__sympy-17163

17,163

sympy/sympy

1.5

fa8328d1cd9e7af7c81fdef579e788038465b665

2019-07-07T16:09:54Z

diff --git a/sympy/stats/__init__.py b/sympy/stats/__init__.py index 5364fce2185d..a9e304e726e2 100644 --- a/sympy/stats/__init__.py +++ b/sympy/stats/__init__.py @@ -83,10 +83,13 @@ from . import stochastic_process_types from .stochastic_process_types import ( StochasticProcess, + ContinuousTimeStochasticProcess, DiscreteTimeStochasticProcess, DiscreteMarkovChain, TransitionMatrixOf, - StochasticStateSpaceOf + StochasticStateSpaceOf, + ContinuousMarkovChain, + GeneratorMatrixOf ) __all__.extend(stochastic_process_types.__all__) diff --git a/sympy/stats/rv.py b/sympy/stats/rv.py index 55cb363b7301..43250c1a4044 100644 --- a/sympy/stats/rv.py +++ b/sympy/stats/rv.py @@ -17,7 +17,7 @@ from sympy import (Basic, S, Expr, Symbol, Tuple, And, Add, Eq, lambdify, Equality, Lambda, sympify, Dummy, Ne, KroneckerDelta, - DiracDelta, Mul, Indexed) + DiracDelta, Mul, Indexed, Function) from sympy.core.compatibility import string_types from sympy.core.relational import Relational from sympy.logic.boolalg import Boolean @@ -275,13 +275,19 @@ def free_symbols(self): class RandomIndexedSymbol(RandomSymbol): def __new__(cls, idx_obj, pspace=None): - if not isinstance(idx_obj, Indexed): - raise TypeError("An indexed object is expected not %s"%(idx_obj)) + if not isinstance(idx_obj, (Indexed, Function)): + raise TypeError("An Function or Indexed object is expected not %s"%(idx_obj)) return Basic.__new__(cls, idx_obj, pspace) symbol = property(lambda self: self.args[0]) name = property(lambda self: str(self.args[0])) - key = property(lambda self: self.symbol.args[1]) + + @property + def key(self): + if isinstance(self.symbol, Indexed): + return self.symbol.args[1] + elif isinstance(self.symbol, Function): + return self.symbol.args[0] class ProductPSpace(PSpace): """ diff --git a/sympy/stats/stochastic_process_types.py b/sympy/stats/stochastic_process_types.py index 66f0a57edece..e31bb9ace802 100644 --- a/sympy/stats/stochastic_process_types.py +++ b/sympy/stats/stochastic_process_types.py @@ -1,10 +1,11 @@ from __future__ import print_function, division from sympy import (Symbol, Matrix, MatrixSymbol, S, Indexed, Basic, - Set, And, Eq, FiniteSet, ImmutableMatrix, - Lambda, Mul, Sum, Dummy, Lt, IndexedBase, - linsolve, eye, Or, Ne, Not, Intersection, - Expr) + Set, And, Tuple, Eq, FiniteSet, ImmutableMatrix, + nsimplify, Lambda, Mul, Sum, Dummy, Lt, IndexedBase, + linsolve, Piecewise, eye, Or, Ne, Not, Intersection, + Union, Expr, Function, sympify, Le, exp, cacheit, Gt, + Ge) from sympy.core.relational import Relational from sympy.logic.boolalg import Boolean from sympy.stats.joint_rv import JointDistributionHandmade, JointDistribution @@ -18,7 +19,9 @@ 'DiscreteTimeStochasticProcess', 'DiscreteMarkovChain', 'TransitionMatrixOf', - 'StochasticStateSpaceOf' + 'StochasticStateSpaceOf', + 'GeneratorMatrixOf', + 'ContinuousMarkovChain' ] def _set_converter(itr): @@ -171,6 +174,25 @@ def __getitem__(self, time): pspace_obj = StochasticPSpace(self.symbol, self) return RandomIndexedSymbol(idx_obj, pspace_obj) +class ContinuousTimeStochasticProcess(StochasticProcess): + """ + Base class for all continuous time stochastic process. + """ + def __call__(self, time): + """ + For indexing continuous time stochastic processes. + + Returns + ======= + + RandomIndexedSymbol + """ + if time not in self.index_set: + raise IndexError("%s is not in the index set of %s"%(time, self.symbol)) + func_obj = Function(self.symbol)(time) + pspace_obj = StochasticPSpace(self.symbol, self) + return RandomIndexedSymbol(func_obj, pspace_obj) + class TransitionMatrixOf(Boolean): """ Assumes that the matrix is the transition matrix @@ -187,11 +209,24 @@ def __new__(cls, process, matrix): process = property(lambda self: self.args[0]) matrix = property(lambda self: self.args[1]) +class GeneratorMatrixOf(TransitionMatrixOf): + """ + Assumes that the matrix is the generator matrix + of the process. + """ + + def __new__(cls, process, matrix): + if not isinstance(process, ContinuousMarkovChain): + raise ValueError("Currently only ContinuousMarkovChain " + "support GeneratorMatrixOf.") + matrix = _matrix_checks(matrix) + return Basic.__new__(cls, process, matrix) + class StochasticStateSpaceOf(Boolean): def __new__(cls, process, state_space): - if not isinstance(process, DiscreteMarkovChain): - raise ValueError("Currently only DiscreteMarkovChain " + if not isinstance(process, (DiscreteMarkovChain, ContinuousMarkovChain)): + raise ValueError("Currently only DiscreteMarkovChain and ContinuousMarkovChain " "support StochasticStateSpaceOf.") state_space = _set_converter(state_space) return Basic.__new__(cls, process, state_space) @@ -199,64 +234,21 @@ def __new__(cls, process, state_space): process = property(lambda self: self.args[0]) state_space = property(lambda self: self.args[1]) -class DiscreteMarkovChain(DiscreteTimeStochasticProcess): +class MarkovProcess(StochasticProcess): """ - Represents discrete Markov chain. - - Parameters - ========== - - sym: Symbol - state_space: Set - Optional, by default, S.Reals - trans_probs: Matrix/ImmutableMatrix/MatrixSymbol - Optional, by default, None - - Examples - ======== - - >>> from sympy.stats import DiscreteMarkovChain, TransitionMatrixOf - >>> from sympy import Matrix, MatrixSymbol, Eq - >>> from sympy.stats import P - >>> T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]]) - >>> Y = DiscreteMarkovChain("Y", [0, 1, 2], T) - >>> YS = DiscreteMarkovChain("Y") - >>> Y.state_space - {0, 1, 2} - >>> Y.transition_probabilities - Matrix([ - [0.5, 0.2, 0.3], - [0.2, 0.5, 0.3], - [0.2, 0.3, 0.5]]) - >>> TS = MatrixSymbol('T', 3, 3) - >>> P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TS)) - T[0, 2]*T[1, 0] + T[1, 1]*T[1, 2] + T[1, 2]*T[2, 2] - >>> P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) - 0.36 + Contains methods that handle queries + common to Markov processes. """ - index_set = S.Naturals0 - - def __new__(cls, sym, state_space=S.Reals, trans_probs=None): - sym = _symbol_converter(sym) - state_space = _set_converter(state_space) - if trans_probs != None: - trans_probs = _matrix_checks(trans_probs) - return Basic.__new__(cls, sym, state_space, trans_probs) - - @property - def transition_probabilities(self): - """ - Transition probabilities of discrete Markov chain, - either an instance of Matrix or MatrixSymbol. - """ - return self.args[2] - def _extract_information(self, given_condition): """ Helper function to extract information, like, - transition probabilities, state space, etc. + transition matrix/generator matrix, state space, etc. """ - trans_probs, state_space = self.transition_probabilities, self.state_space + if isinstance(self, DiscreteMarkovChain): + trans_probs = self.transition_probabilities + elif isinstance(self, ContinuousMarkovChain): + trans_probs = self.generator_matrix + state_space = self.state_space if isinstance(given_condition, And): gcs = given_condition.args given_condition = S.true @@ -269,11 +261,13 @@ def _extract_information(self, given_condition): given_condition = given_condition & gc if isinstance(given_condition, TransitionMatrixOf): trans_probs = given_condition.matrix + given_condition = S.true if isinstance(given_condition, StochasticStateSpaceOf): state_space = given_condition.state_space + given_condition = S.true return trans_probs, state_space, given_condition - def _check_trans_probs(self, trans_probs): + def _check_trans_probs(self, trans_probs, row_sum=1): """ Helper function for checking the validity of transition probabilities. @@ -281,9 +275,9 @@ def _check_trans_probs(self, trans_probs): if not isinstance(trans_probs, MatrixSymbol): rows = trans_probs.tolist() for row in rows: - if (sum(row) - 1) != 0: - raise ValueError("Probabilities in a row must sum to 1. " - "If you are using Float or floats then please use Rational.") + if (sum(row) - row_sum) != 0: + raise ValueError("Values in a row must sum to %s. " + "If you are using Float or floats then please use Rational."%(row_sum)) def _work_out_state_space(self, state_space, given_condition, trans_probs): """ @@ -302,6 +296,7 @@ def _work_out_state_space(self, state_space, given_condition, trans_probs): state_space = FiniteSet(*[i for i in range(trans_probs.shape[0])]) return state_space + @cacheit def _preprocess(self, given_condition, evaluate): """ Helper function for pre-processing the information. @@ -321,13 +316,284 @@ def _preprocess(self, given_condition, evaluate): is_insufficient = True else: # checking transition probabilities - self._check_trans_probs(trans_probs) + if isinstance(self, DiscreteMarkovChain): + self._check_trans_probs(trans_probs, row_sum=1) + elif isinstance(self, ContinuousMarkovChain): + self._check_trans_probs(trans_probs, row_sum=0) # working out state space state_space = self._work_out_state_space(state_space, given_condition, trans_probs) return is_insufficient, trans_probs, state_space, given_condition + def probability(self, condition, given_condition=None, evaluate=True, **kwargs): + """ + Handles probability queries for Markov process. + + Parameters + ========== + + condition: Relational + given_condition: Relational/And + + Returns + ======= + Probability + If the information is not sufficient. + Expr + In all other cases. + + Note + ==== + Any information passed at the time of query overrides + any information passed at the time of object creation like + transition probabilities, state space. + Pass the transition matrix using TransitionMatrixOf, + generator matrix using GeneratorMatrixOf and state space + using StochasticStateSpaceOf in given_condition using & or And. + """ + check, mat, state_space, new_given_condition = \ + self._preprocess(given_condition, evaluate) + + if check: + return Probability(condition, new_given_condition) + + if isinstance(self, ContinuousMarkovChain): + trans_probs = self.transition_probabilities(mat) + elif isinstance(self, DiscreteMarkovChain): + trans_probs = mat + + if isinstance(condition, Relational): + rv, states = (list(condition.atoms(RandomIndexedSymbol))[0], condition.as_set()) + if isinstance(new_given_condition, And): + gcs = new_given_condition.args + else: + gcs = (new_given_condition, ) + grvs = new_given_condition.atoms(RandomIndexedSymbol) + + min_key_rv = None + for grv in grvs: + if grv.key <= rv.key: + min_key_rv = grv + if min_key_rv == None: + return Probability(condition) + + prob, gstate = dict(), None + for gc in gcs: + if gc.has(min_key_rv): + if gc.has(Probability): + p, gp = (gc.rhs, gc.lhs) if isinstance(gc.lhs, Probability) \ + else (gc.lhs, gc.rhs) + gr = gp.args[0] + gset = Intersection(gr.as_set(), state_space) + gstate = list(gset)[0] + prob[gset] = p + else: + _, gstate = (gc.lhs.key, gc.rhs) if isinstance(gc.lhs, RandomIndexedSymbol) \ + else (gc.rhs.key, gc.lhs) + + if any((k not in self.index_set) for k in (rv.key, min_key_rv.key)): + raise IndexError("The timestamps of the process are not in it's index set.") + states = Intersection(states, state_space) + for state in Union(states, FiniteSet(gstate)): + if Ge(state, mat.shape[0]) == True: + raise IndexError("No information is available for (%s, %s) in " + "transition probabilities of shape, (%s, %s). " + "State space is zero indexed." + %(gstate, state, mat.shape[0], mat.shape[1])) + if prob: + gstates = Union(*prob.keys()) + if len(gstates) == 1: + gstate = list(gstates)[0] + gprob = list(prob.values())[0] + prob[gstates] = gprob + elif len(gstates) == len(state_space) - 1: + gstate = list(state_space - gstates)[0] + gprob = S(1) - sum(prob.values()) + prob[state_space - gstates] = gprob + else: + raise ValueError("Conflicting information.") + else: + gprob = S(1) + + if min_key_rv == rv: + return sum([prob[FiniteSet(state)] for state in states]) + if isinstance(self, ContinuousMarkovChain): + return gprob * sum([trans_probs(rv.key - min_key_rv.key).__getitem__((gstate, state)) + for state in states]) + if isinstance(self, DiscreteMarkovChain): + return gprob * sum([(trans_probs**(rv.key - min_key_rv.key)).__getitem__((gstate, state)) + for state in states]) + + if isinstance(condition, Not): + expr = condition.args[0] + return S(1) - self.probability(expr, given_condition, evaluate, **kwargs) + + if isinstance(condition, And): + compute_later, state2cond, conds = [], dict(), condition.args + for expr in conds: + if isinstance(expr, Relational): + ris = list(expr.atoms(RandomIndexedSymbol))[0] + if state2cond.get(ris, None) is None: + state2cond[ris] = S.true + state2cond[ris] &= expr + else: + compute_later.append(expr) + ris = [] + for ri in state2cond: + ris.append(ri) + cset = Intersection(state2cond[ri].as_set(), state_space) + if len(cset) == 0: + return S.Zero + state2cond[ri] = cset.as_relational(ri) + sorted_ris = sorted(ris, key=lambda ri: ri.key) + prod = self.probability(state2cond[sorted_ris[0]], given_condition, evaluate, **kwargs) + for i in range(1, len(sorted_ris)): + ri, prev_ri = sorted_ris[i], sorted_ris[i-1] + if not isinstance(state2cond[ri], Eq): + raise ValueError("The process is in multiple states at %s, unable to determine the probability."%(ri)) + mat_of = TransitionMatrixOf(self, mat) if isinstance(self, DiscreteMarkovChain) else GeneratorMatrixOf(self, mat) + prod *= self.probability(state2cond[ri], state2cond[prev_ri] + & mat_of + & StochasticStateSpaceOf(self, state_space), + evaluate, **kwargs) + for expr in compute_later: + prod *= self.probability(expr, given_condition, evaluate, **kwargs) + return prod + + if isinstance(condition, Or): + return sum([self.probability(expr, given_condition, evaluate, **kwargs) + for expr in condition.args]) + + raise NotImplementedError("Mechanism for handling (%s, %s) queries hasn't been " + "implemented yet."%(expr, condition)) + + def expectation(self, expr, condition=None, evaluate=True, **kwargs): + """ + Handles expectation queries for markov process. + + Parameters + ========== + + expr: RandomIndexedSymbol, Relational, Logic + Condition for which expectation has to be computed. Must + contain a RandomIndexedSymbol of the process. + condition: Relational, Logic + The given conditions under which computations should be done. + + Returns + ======= + + Expectation + Unevaluated object if computations cannot be done due to + insufficient information. + Expr + In all other cases when the computations are successful. + + Note + ==== + + Any information passed at the time of query overrides + any information passed at the time of object creation like + transition probabilities, state space. + + Pass the transition matrix using TransitionMatrixOf, + generator matrix using GeneratorMatrixOf and state space + using StochasticStateSpaceOf in given_condition using & or And. + """ + + check, mat, state_space, condition = \ + self._preprocess(condition, evaluate) + + if check: + return Expectation(expr, condition) + + if isinstance(self, ContinuousMarkovChain): + trans_probs = self.transition_probabilities(mat) + elif isinstance(self, DiscreteMarkovChain): + trans_probs = mat + + rvs = random_symbols(expr) + if isinstance(expr, Expr) and isinstance(condition, Eq) \ + and len(rvs) == 1: + # handle queries similar to E(f(X[i]), Eq(X[i-m], <some-state>)) + rv = list(rvs)[0] + lhsg, rhsg = condition.lhs, condition.rhs + if not isinstance(lhsg, RandomIndexedSymbol): + lhsg, rhsg = (rhsg, lhsg) + if rhsg not in self.state_space: + raise ValueError("%s state is not in the state space."%(rhsg)) + if rv.key < lhsg.key: + raise ValueError("Incorrect given condition is given, expectation " + "time %s < time %s"%(rv.key, rv.key)) + mat_of = TransitionMatrixOf(self, mat) if isinstance(self, DiscreteMarkovChain) else GeneratorMatrixOf(self, mat) + cond = condition & mat_of & \ + StochasticStateSpaceOf(self, state_space) + s = Dummy('s') + func = lambda s: self.probability(Eq(rv, s), cond)*expr.subs(rv, s) + return sum([func(s) for s in state_space]) + + raise NotImplementedError("Mechanism for handling (%s, %s) queries hasn't been " + "implemented yet."%(expr, condition)) + +class DiscreteMarkovChain(DiscreteTimeStochasticProcess, MarkovProcess): + """ + Represents discrete time Markov chain. + + Parameters + ========== + + sym: Symbol/string_types + state_space: Set + Optional, by default, S.Reals + trans_probs: Matrix/ImmutableMatrix/MatrixSymbol + Optional, by default, None + + Examples + ======== + + >>> from sympy.stats import DiscreteMarkovChain, TransitionMatrixOf + >>> from sympy import Matrix, MatrixSymbol, Eq + >>> from sympy.stats import P + >>> T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]]) + >>> Y = DiscreteMarkovChain("Y", [0, 1, 2], T) + >>> YS = DiscreteMarkovChain("Y") + >>> Y.state_space + {0, 1, 2} + >>> Y.transition_probabilities + Matrix([ + [0.5, 0.2, 0.3], + [0.2, 0.5, 0.3], + [0.2, 0.3, 0.5]]) + >>> TS = MatrixSymbol('T', 3, 3) + >>> P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TS)) + T[0, 2]*T[1, 0] + T[1, 1]*T[1, 2] + T[1, 2]*T[2, 2] + >>> P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) + 0.36 + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Markov_chain#Discrete-time_Markov_chain + .. [2] https://www.dartmouth.edu/~chance/teaching_aids/books_articles/probability_book/Chapter11.pdf + """ + index_set = S.Naturals0 + + def __new__(cls, sym, state_space=S.Reals, trans_probs=None): + sym = _symbol_converter(sym) + state_space = _set_converter(state_space) + if trans_probs != None: + trans_probs = _matrix_checks(trans_probs) + return Basic.__new__(cls, sym, state_space, trans_probs) + + @property + def transition_probabilities(self): + """ + Transition probabilities of discrete Markov chain, + either an instance of Matrix or MatrixSymbol. + """ + return self.args[2] + def _transient2transient(self): """ Computes the one step probabilities of transient @@ -432,186 +698,70 @@ def limiting_distribution(self): """ return self.fixed_row_vector() - def probability(self, condition, given_condition=None, evaluate=True, **kwargs): - """ - Handles probability queries for discrete Markov chains. - - Parameters - ========== - - condition: Relational - given_condition: Relational/And - - Returns - ======= - - Probability - If the transition probabilities are not available - Expr - If the transition probabilities is MatrixSymbol or Matrix - - Note - ==== - - Any information passed at the time of query overrides - any information passed at the time of object creation like - transition probabilities, state space. - - Pass the transition matrix using TransitionMatrixOf and state space - using StochasticStateSpaceOf in given_condition using & or And. - """ - - check, trans_probs, state_space, given_condition = \ - self._preprocess(given_condition, evaluate) - - if check: - return Probability(condition, given_condition) - - if isinstance(condition, Eq) and \ - isinstance(given_condition, Eq) and \ - len(given_condition.atoms(RandomSymbol)) == 1: - # handles simple queries like P(Eq(X[i], dest_state), Eq(X[i], init_state)) - lhsc, rhsc = condition.lhs, condition.rhs - lhsg, rhsg = given_condition.lhs, given_condition.rhs - if not isinstance(lhsc, RandomIndexedSymbol): - lhsc, rhsc = (rhsc, lhsc) - if not isinstance(lhsg, RandomIndexedSymbol): - lhsg, rhsg = (rhsg, lhsg) - keyc, statec, keyg, stateg = (lhsc.key, rhsc, lhsg.key, rhsg) - if Lt(stateg, trans_probs.shape[0]) == False or Lt(statec, trans_probs.shape[1]) == False: - raise IndexError("No information is available for (%s, %s) in " - "transition probabilities of shape, (%s, %s). " - "State space is zero indexed." - %(stateg, statec, trans_probs.shape[0], trans_probs.shape[1])) - if keyc < keyg: - raise ValueError("Incorrect given condition is given, probability " - "of past state cannot be computed from future state.") - nsteptp = trans_probs**(keyc - keyg) - if hasattr(nsteptp, "__getitem__"): - return nsteptp.__getitem__((stateg, statec)) - return Indexed(nsteptp, stateg, statec) - - info = TransitionMatrixOf(self, trans_probs) & StochasticStateSpaceOf(self, state_space) - new_gc = given_condition & info - - if isinstance(condition, And): - # handle queries like, - # P(Eq(X[i+k], s1) & Eq(X[i+m], s2) . . . & Eq(X[i], sn), Eq(P(Eq(X[i], si)), prob)) - conds = condition.args - idx2state = dict() - for cond in conds: - idx, state = (cond.lhs, cond.rhs) if isinstance(cond.lhs, RandomIndexedSymbol) else \ - (cond.rhs, cond.lhs) - idx2state[idx] = cond if idx2state.get(idx, None) is None else \ - idx2state[idx] & cond - if any(len(Intersection(idx2state[idx].as_set(), state_space)) != 1 - for idx in idx2state): - return S.Zero # a RandomIndexedSymbol cannot go to different states simultaneously - i, result = -1, 1 - conds = And.fromiter(Intersection(idx2state[idx].as_set(), state_space).as_relational(idx) - for idx in idx2state) - if not isinstance(conds, And): - return self.probability(conds, new_gc) - conds = conds.args - while i > -len(conds): - result *= self.probability(conds[i], conds[i-1] & info) - i -= 1 - if isinstance(given_condition, (TransitionMatrixOf, StochasticStateSpaceOf)): - return result * Probability(conds[i]) - if isinstance(given_condition, And): - idx_sym = conds[i].atoms(RandomIndexedSymbol) - prob, count = S(0), 0 - for gc in given_condition.args: - if gc.atoms(RandomIndexedSymbol) == idx_sym: - prob += gc.rhs if isinstance(gc.lhs, Probability) else gc.lhs - count += 1 - if isinstance(state_space, FiniteSet) and \ - count == len(state_space) - 1: - given_condition = Eq(Probability(conds[i]), S(1) - prob) - if isinstance(given_condition, Eq): - if not isinstance(given_condition.lhs, Probability) or \ - given_condition.lhs.args[0] != conds[i]: - raise ValueError("Probability for %s needed", conds[i]) - return result * given_condition.rhs - - if isinstance(condition, Or): - conds, prob_sum = condition.args, S(0) - idx2state = dict() - for cond in conds: - idx, state = (cond.lhs, cond.rhs) if isinstance(cond.lhs, RandomIndexedSymbol) else \ - (cond.rhs, cond.lhs) - idx2state[idx] = cond if idx2state.get(idx, None) is None else \ - idx2state[idx] | cond - conds = Or.fromiter(Intersection(idx2state[idx].as_set(), state_space).as_relational(idx) - for idx in idx2state) - if not isinstance(conds, Or): - return self.probability(conds, new_gc) - return sum([self.probability(cond, new_gc) for cond in conds.args]) - - if isinstance(condition, Ne): - prob = self.probability(Not(condition), new_gc) - return S(1) - prob - - raise NotImplementedError("Mechanism for handling (%s, %s) queries hasn't been " - "implemented yet."%(condition, given_condition)) - - def expectation(self, expr, condition=None, evaluate=True, **kwargs): - """ - Handles expectation queries for discrete markov chains. +class ContinuousMarkovChain(ContinuousTimeStochasticProcess, MarkovProcess): + """ + Represents continuous time Markov chain. - Parameters - ========== + Parameters + ========== - expr: RandomIndexedSymbol, Relational, Logic - Condition for which expectation has to be computed. Must - contain a RandomIndexedSymbol of the process. - condition: Relational, Logic - The given conditions under which computations should be done. + sym: Symbol/string_types + state_space: Set + Optional, by default, S.Reals + gen_mat: Matrix/ImmutableMatrix/MatrixSymbol + Optional, by default, None - Returns - ======= + Examples + ======== - Expectation - Unevaluated object if computations cannot be done due to - insufficient information. - Expr - In all other cases when the computations are successful. + >>> from sympy.stats import ContinuousMarkovChain + >>> from sympy import Matrix, S, MatrixSymbol + >>> G = Matrix([[-S(1), S(1)], [S(1), -S(1)]]) + >>> C = ContinuousMarkovChain('C', state_space=[0, 1], gen_mat=G) + >>> C.limiting_distribution() + Matrix([[1/2, 1/2]]) - Note - ==== - - Any information passed at the time of query overrides - any information passed at the time of object creation like - transition probabilities, state space. + References + ========== - Pass the transition matrix using TransitionMatrixOf and state space - using StochasticStateSpaceOf in given_condition using & or And. - """ + .. [1] https://en.wikipedia.org/wiki/Markov_chain#Continuous-time_Markov_chain + .. [2] http://u.math.biu.ac.il/~amirgi/CTMCnotes.pdf + """ + index_set = S.Reals - check, trans_probs, state_space, condition = \ - self._preprocess(condition, evaluate) + def __new__(cls, sym, state_space=S.Reals, gen_mat=None): + sym = _symbol_converter(sym) + state_space = _set_converter(state_space) + if gen_mat != None: + gen_mat = _matrix_checks(gen_mat) + return Basic.__new__(cls, sym, state_space, gen_mat) - if check: - return Expectation(expr, condition) + @property + def generator_matrix(self): + return self.args[2] - rvs = random_symbols(expr) - if isinstance(expr, Expr) and isinstance(condition, Eq) \ - and len(rvs) == 1: - # handle queries similar to E(f(X[i]), Eq(X[i-m], <some-state>)) - rv = list(rvs)[0] - lhsg, rhsg = condition.lhs, condition.rhs - if not isinstance(lhsg, RandomIndexedSymbol): - lhsg, rhsg = (rhsg, lhsg) - if rhsg not in self.state_space: - raise ValueError("%s state is not in the state space."%(rhsg)) - if rv.key < lhsg.key: - raise ValueError("Incorrect given condition is given, expectation " - "time %s < time %s"%(rv.key, rv.key)) - cond = condition & TransitionMatrixOf(self, trans_probs) & \ - StochasticStateSpaceOf(self, state_space) - s = Dummy('s') - func = Lambda(s, self.probability(Eq(rv, s), cond)*expr.subs(rv, s)) - return Sum(func(s), (s, state_space.inf, state_space.sup)).doit() + @cacheit + def transition_probabilities(self, gen_mat=None): + t = Dummy('t') + if isinstance(gen_mat, (Matrix, ImmutableMatrix)) and \ + gen_mat.is_diagonalizable(): + # for faster computation use diagonalized generator matrix + Q, D = gen_mat.diagonalize() + return Lambda(t, Q*exp(t*D)*Q.inv()) + if gen_mat != None: + return Lambda(t, exp(t*gen_mat)) - raise NotImplementedError("Mechanism for handling (%s, %s) queries hasn't been " - "implemented yet."%(expr, condition)) + def limiting_distribution(self): + gen_mat = self.generator_matrix + if gen_mat == None: + return None + if isinstance(gen_mat, MatrixSymbol): + wm = MatrixSymbol('wm', 1, gen_mat.shape[0]) + return Lambda((wm, gen_mat), Eq(wm*gen_mat, wm)) + w = IndexedBase('w') + wi = [w[i] for i in range(gen_mat.shape[0])] + wm = Matrix([wi]) + eqs = (wm*gen_mat).tolist()[0] + eqs.append(sum(wi) - 1) + soln = list(linsolve(eqs, wi))[0] + return ImmutableMatrix([[sol for sol in soln]])

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 131bcd80a6c8..a2ad8d3fb2e3 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1563,16 +1563,30 @@ def test_sympy__stats__stochastic_process_types__StochasticProcess(): from sympy.stats.stochastic_process_types import StochasticProcess assert _test_args(StochasticProcess("Y", [1, 2, 3])) +def test_sympy__stats__stochastic_process_types__MarkovProcess(): + from sympy.stats.stochastic_process_types import MarkovProcess + assert _test_args(MarkovProcess("Y", [1, 2, 3])) + def test_sympy__stats__stochastic_process_types__DiscreteTimeStochasticProcess(): from sympy.stats.stochastic_process_types import DiscreteTimeStochasticProcess assert _test_args(DiscreteTimeStochasticProcess("Y", [1, 2, 3])) +def test_sympy__stats__stochastic_process_types__ContinuousTimeStochasticProcess(): + from sympy.stats.stochastic_process_types import ContinuousTimeStochasticProcess + assert _test_args(ContinuousTimeStochasticProcess("Y", [1, 2, 3])) + def test_sympy__stats__stochastic_process_types__TransitionMatrixOf(): from sympy.stats.stochastic_process_types import TransitionMatrixOf, DiscreteMarkovChain from sympy import MatrixSymbol DMC = DiscreteMarkovChain("Y") assert _test_args(TransitionMatrixOf(DMC, MatrixSymbol('T', 3, 3))) +def test_sympy__stats__stochastic_process_types__GeneratorMatrixOf(): + from sympy.stats.stochastic_process_types import GeneratorMatrixOf, ContinuousMarkovChain + from sympy import MatrixSymbol + DMC = ContinuousMarkovChain("Y") + assert _test_args(GeneratorMatrixOf(DMC, MatrixSymbol('T', 3, 3))) + def test_sympy__stats__stochastic_process_types__StochasticStateSpaceOf(): from sympy.stats.stochastic_process_types import StochasticStateSpaceOf, DiscreteMarkovChain from sympy import MatrixSymbol @@ -1584,6 +1598,11 @@ def test_sympy__stats__stochastic_process_types__DiscreteMarkovChain(): from sympy import MatrixSymbol assert _test_args(DiscreteMarkovChain("Y", [0, 1, 2], MatrixSymbol('T', 3, 3))) +def test_sympy__stats__stochastic_process_types__ContinuousMarkovChain(): + from sympy.stats.stochastic_process_types import ContinuousMarkovChain + from sympy import MatrixSymbol + assert _test_args(ContinuousMarkovChain("Y", [0, 1, 2], MatrixSymbol('T', 3, 3))) + def test_sympy__core__symbol__Dummy(): from sympy.core.symbol import Dummy assert _test_args(Dummy('t')) diff --git a/sympy/stats/tests/test_stochastic_process.py b/sympy/stats/tests/test_stochastic_process.py index 5da55684eb3f..2729856a171a 100644 --- a/sympy/stats/tests/test_stochastic_process.py +++ b/sympy/stats/tests/test_stochastic_process.py @@ -1,7 +1,7 @@ from sympy import (S, symbols, FiniteSet, Eq, Matrix, MatrixSymbol, Float, And, - ImmutableMatrix, Ne, Lt, Gt) + ImmutableMatrix, Ne, Lt, Gt, exp, Not) from sympy.stats import (DiscreteMarkovChain, P, TransitionMatrixOf, E, - StochasticStateSpaceOf, variance) + StochasticStateSpaceOf, variance, ContinuousMarkovChain) from sympy.stats.joint_rv import JointDistribution from sympy.stats.rv import RandomIndexedSymbol from sympy.stats.symbolic_probability import Probability, Expectation @@ -41,6 +41,8 @@ def test_DiscreteMarkovChain(): assert P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) == Float(0.36, 2) assert str(P(Eq(YS[3], 2), Eq(YS[1], 1))) == \ "T[0, 2]*T[1, 0] + T[1, 1]*T[1, 2] + T[1, 2]*T[2, 2]" + assert P(Eq(YS[1], 1), Eq(YS[2], 2)) == Probability(Eq(YS[1], 1)) + assert P(Eq(YS[3], 3), Eq(YS[1], 1)) == S.Zero TO = Matrix([[0.25, 0.75, 0],[0, 0.25, 0.75],[0.75, 0, 0.25]]) assert P(Eq(Y[3], 2), Eq(Y[1], 1) & TransitionMatrixOf(Y, TO)).round(3) == Float(0.375, 3) assert E(Y[3], evaluate=False) == Expectation(Y[3]) @@ -49,8 +51,6 @@ def test_DiscreteMarkovChain(): raises(ValueError, lambda: str(P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TSO)))) raises(TypeError, lambda: DiscreteMarkovChain("Z", [0, 1, 2], symbols('M'))) raises(ValueError, lambda: DiscreteMarkovChain("Z", [0, 1, 2], MatrixSymbol('T', 3, 4))) - raises(IndexError, lambda: str(P(Eq(YS[3], 3), Eq(YS[1], 1)))) - raises(ValueError, lambda: str(P(Eq(YS[1], 1), Eq(YS[2], 2)))) raises(ValueError, lambda: E(Y[3], Eq(Y[2], 6))) raises(ValueError, lambda: E(Y[2], Eq(Y[3], 1))) @@ -65,7 +65,7 @@ def test_DiscreteMarkovChain(): StochasticStateSpaceOf(X, [0, 1, 2]) & TransitionMatrixOf(X, TO1)) == S(1)/4 assert P(Ne(X[1], 2) & Ne(X[1], 1), Eq(X[0], 2) & StochasticStateSpaceOf(X, [0, 1, 2]) & TransitionMatrixOf(X, TO1)) == S(0) - raises (ValueError, lambda: str(P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)), Eq(Y[1], 1)))) + assert P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)), Eq(Y[1], 1)) == 0.1*Probability(Eq(Y[0], 0)) # testing properties of Markov chain TO2 = Matrix([[S(1), 0, 0],[S(1)/3, S(1)/3, S(1)/3],[0, S(1)/4, S(3)/4]]) @@ -92,7 +92,9 @@ def test_DiscreteMarkovChain(): assert Y6.absorbing_probabilites() == ImmutableMatrix([[S(3)/4, S(1)/4], [S(1)/2, S(1)/2], [S(1)/4, S(3)/4]]) # testing miscellaneous queries - T = Matrix([[S(1)/2, S(1)/4, S(1)/4], [S(1)/3, 0, S(2)/3], [S(1)/2, S(1)/2, 0]]) + T = Matrix([[S(1)/2, S(1)/4, S(1)/4], + [S(1)/3, 0, S(2)/3], + [S(1)/2, S(1)/2, 0]]) X = DiscreteMarkovChain('X', [0, 1, 2], T) assert P(Eq(X[1], 2) & Eq(X[2], 1) & Eq(X[3], 0), Eq(P(Eq(X[1], 0)), S(1)/4) & Eq(P(Eq(X[1], 1)), S(1)/4)) == S(1)/12 @@ -102,3 +104,33 @@ def test_DiscreteMarkovChain(): assert E(X[1]**2, Eq(X[0], 1)) == S(8)/3 assert variance(X[1], Eq(X[0], 1)) == S(8)/9 raises(ValueError, lambda: E(X[1], Eq(X[2], 1))) + +def test_ContinuousMarkovChain(): + T1 = Matrix([[S(-2), S(2), S(0)], + [S(0), S(-1), S(1)], + [S(3)/2, S(3)/2, S(-3)]]) + C1 = ContinuousMarkovChain('C', [0, 1, 2], T1) + assert C1.limiting_distribution() == ImmutableMatrix([[S(3)/19, S(12)/19, S(4)/19]]) + + T2 = Matrix([[-S(1), S(1), S(0)], [S(1), -S(1), S(0)], [S(0), S(1), -S(1)]]) + C2 = ContinuousMarkovChain('C', [0, 1, 2], T2) + A, t = C2.generator_matrix, symbols('t', positive=True) + assert C2.transition_probabilities(A)(t) == Matrix([[S(1)/2 + exp(-2*t)/2, S(1)/2 - exp(-2*t)/2, 0], + [S(1)/2 - exp(-2*t)/2, S(1)/2 + exp(-2*t)/2, 0], + [S(1)/2 - exp(-t) + exp(-2*t)/2, S(1)/2 - exp(-2*t)/2, exp(-t)]]) + assert P(Eq(C2(1), 1), Eq(C2(0), 1), evaluate=False) == Probability(Eq(C2(1), 1)) + assert P(Eq(C2(1), 1), Eq(C2(0), 1)) == exp(-2)/2 + S(1)/2 + assert P(Eq(C2(1), 0) & Eq(C2(2), 1) & Eq(C2(3), 1), + Eq(P(Eq(C2(1), 0)), S(1)/2)) == (S(1)/4 - exp(-2)/4)*(exp(-2)/2 + S(1)/2) + assert P(Not(Eq(C2(1), 0) & Eq(C2(2), 1) & Eq(C2(3), 2)) | + (Eq(C2(1), 0) & Eq(C2(2), 1) & Eq(C2(3), 2)), + Eq(P(Eq(C2(1), 0)), S(1)/4) & Eq(P(Eq(C2(1), 1)), S(1)/4)) == S(1) + assert E(C2(S(3)/2), Eq(C2(0), 2)) == -exp(-3)/2 + 2*exp(-S(3)/2) + S(1)/2 + assert variance(C2(S(3)/2), Eq(C2(0), 1)) == ((S(1)/2 - exp(-3)/2)**2*(exp(-3)/2 + S(1)/2) + + (-S(1)/2 - exp(-3)/2)**2*(S(1)/2 - exp(-3)/2)) + raises(KeyError, lambda: P(Eq(C2(1), 0), Eq(P(Eq(C2(1), 1)), S(1)/2))) + assert P(Eq(C2(1), 0), Eq(P(Eq(C2(5), 1)), S(1)/2)) == Probability(Eq(C2(1), 0)) + TS1 = MatrixSymbol('G', 3, 3) + CS1 = ContinuousMarkovChain('C', [0, 1, 2], TS1) + A = CS1.generator_matrix + assert CS1.transition_probabilities(A)(t) == exp(t*A)

[ { "components": [ { "doc": "", "lines": [ 286, 290 ], "name": "RandomIndexedSymbol.key", "signature": "def key(self):", "type": "function" } ], "file": "sympy/stats/rv.py" }, { "components": [ { "doc": ...

[ "test_sympy__stats__stochastic_process_types__MarkovProcess", "test_sympy__stats__stochastic_process_types__ContinuousTimeStochasticProcess", "test_sympy__stats__stochastic_process_types__GeneratorMatrixOf", "test_sympy__stats__stochastic_process_types__ContinuousMarkovChain", "test_DiscreteMarkovChain" ]

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added continuous time Markov chain  #### References to other Issues or PRs  [1] http://u.math.biu.ac.il/~amirgi/CTMCnotes.pdf #### Brief description of what is fixed or changed Continuous time Markov chains have been added. The API is kept similar to `DiscreteMarkovChain`. #### Other comments ping @Upabjojr @sidhantnagpal #### Release Notes   * stats * `ContinuousMarkovChain` have been added to `sympy.stats`  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/rv.py] (definition of RandomIndexedSymbol.key:) def key(self): [end of new definitions in sympy/stats/rv.py] [start of new definitions in sympy/stats/stochastic_process_types.py] (definition of ContinuousTimeStochasticProcess:) class ContinuousTimeStochasticProcess(StochasticProcess): """Base class for all continuous time stochastic process.""" (definition of ContinuousTimeStochasticProcess.__call__:) def __call__(self, time): """For indexing continuous time stochastic processes. Returns ======= RandomIndexedSymbol""" (definition of GeneratorMatrixOf:) class GeneratorMatrixOf(TransitionMatrixOf): """Assumes that the matrix is the generator matrix of the process.""" (definition of GeneratorMatrixOf.__new__:) def __new__(cls, process, matrix): (definition of MarkovProcess:) class MarkovProcess(StochasticProcess): """Contains methods that handle queries common to Markov processes.""" (definition of MarkovProcess._extract_information:) def _extract_information(self, given_condition): """Helper function to extract information, like, transition matrix/generator matrix, state space, etc.""" (definition of MarkovProcess._check_trans_probs:) def _check_trans_probs(self, trans_probs, row_sum=1): """Helper function for checking the validity of transition probabilities.""" (definition of MarkovProcess._work_out_state_space:) def _work_out_state_space(self, state_space, given_condition, trans_probs): """Helper function to extract state space if there is a random symbol in the given condition.""" (definition of MarkovProcess._preprocess:) def _preprocess(self, given_condition, evaluate): """Helper function for pre-processing the information.""" (definition of MarkovProcess.probability:) def probability(self, condition, given_condition=None, evaluate=True, **kwargs): """Handles probability queries for Markov process. Parameters ========== condition: Relational given_condition: Relational/And Returns ======= Probability If the information is not sufficient. Expr In all other cases. Note ==== Any information passed at the time of query overrides any information passed at the time of object creation like transition probabilities, state space. Pass the transition matrix using TransitionMatrixOf, generator matrix using GeneratorMatrixOf and state space using StochasticStateSpaceOf in given_condition using & or And.""" (definition of MarkovProcess.expectation:) def expectation(self, expr, condition=None, evaluate=True, **kwargs): """Handles expectation queries for markov process. Parameters ========== expr: RandomIndexedSymbol, Relational, Logic Condition for which expectation has to be computed. Must contain a RandomIndexedSymbol of the process. condition: Relational, Logic The given conditions under which computations should be done. Returns ======= Expectation Unevaluated object if computations cannot be done due to insufficient information. Expr In all other cases when the computations are successful. Note ==== Any information passed at the time of query overrides any information passed at the time of object creation like transition probabilities, state space. Pass the transition matrix using TransitionMatrixOf, generator matrix using GeneratorMatrixOf and state space using StochasticStateSpaceOf in given_condition using & or And.""" (definition of ContinuousMarkovChain:) class ContinuousMarkovChain(ContinuousTimeStochasticProcess, MarkovProcess): """Represents continuous time Markov chain. Parameters ========== sym: Symbol/string_types state_space: Set Optional, by default, S.Reals gen_mat: Matrix/ImmutableMatrix/MatrixSymbol Optional, by default, None Examples ======== >>> from sympy.stats import ContinuousMarkovChain >>> from sympy import Matrix, S, MatrixSymbol >>> G = Matrix([[-S(1), S(1)], [S(1), -S(1)]]) >>> C = ContinuousMarkovChain('C', state_space=[0, 1], gen_mat=G) >>> C.limiting_distribution() Matrix([[1/2, 1/2]]) References ========== .. [1] https://en.wikipedia.org/wiki/Markov_chain#Continuous-time_Markov_chain .. [2] http://u.math.biu.ac.il/~amirgi/CTMCnotes.pdf""" (definition of ContinuousMarkovChain.__new__:) def __new__(cls, sym, state_space=S.Reals, gen_mat=None): (definition of ContinuousMarkovChain.generator_matrix:) def generator_matrix(self): (definition of ContinuousMarkovChain.transition_probabilities:) def transition_probabilities(self, gen_mat=None): (definition of ContinuousMarkovChain.limiting_distribution:) def limiting_distribution(self): [end of new definitions in sympy/stats/stochastic_process_types.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

scikit-learn__scikit-learn-14263

14,263

scikit-learn/scikit-learn

0.22

70aa46ae8e8f327924ace7b2d70cad7cbd01bf0b

2019-07-05T10:19:05Z

diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 30fc3b5102bc6..ad290ef187aef 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -903,6 +903,9 @@ details. metrics.mean_squared_log_error metrics.median_absolute_error metrics.r2_score + metrics.mean_poisson_deviance + metrics.mean_gamma_deviance + metrics.mean_tweedie_deviance Multilabel ranking metrics -------------------------- diff --git a/doc/modules/model_evaluation.rst b/doc/modules/model_evaluation.rst index 789ffa038f25d..e28d35d985dd8 100644 --- a/doc/modules/model_evaluation.rst +++ b/doc/modules/model_evaluation.rst @@ -91,6 +91,8 @@ Scoring Function 'neg_mean_squared_log_error' :func:`metrics.mean_squared_log_error` 'neg_median_absolute_error' :func:`metrics.median_absolute_error` 'r2' :func:`metrics.r2_score` +'neg_mean_poisson_deviance' :func:`metrics.mean_poisson_deviance` +'neg_mean_gamma_deviance' :func:`metrics.mean_gamma_deviance` ============================== ============================================= ================================== @@ -1957,6 +1959,76 @@ Here is a small example of usage of the :func:`r2_score` function:: for an example of R² score usage to evaluate Lasso and Elastic Net on sparse signals. + +.. _mean_tweedie_deviance: + +Mean Poisson, Gamma, and Tweedie deviances +------------------------------------------ +The :func:`mean_tweedie_deviance` function computes the `mean Tweedie +deviance error +<https://en.wikipedia.org/wiki/Tweedie_distribution#The_Tweedie_deviance>`_ +with power parameter `p`. This is a metric that elicits predicted expectation +values of regression targets. + +Following special cases exist, + +- when `p=0` it is equivalent to :func:`mean_squared_error`. +- when `p=1` it is equivalent to :func:`mean_poisson_deviance`. +- when `p=2` it is equivalent to :func:`mean_gamma_deviance`. + +If :math:`\hat{y}_i` is the predicted value of the :math:`i`-th sample, +and :math:`y_i` is the corresponding true value, then the mean Tweedie +deviance error (D) estimated over :math:`n_{\text{samples}}` is defined as + +.. math:: + + \text{D}(y, \hat{y}) = \frac{1}{n_\text{samples}} + \sum_{i=0}^{n_\text{samples} - 1} + \begin{cases} + (y_i-\hat{y}_i)^2, & \text{for }p=0\text{ (Normal)}\\ + 2(y_i \log(y/\hat{y}_i) + \hat{y}_i - y_i), & \text{for }p=1\text{ (Poisson)}\\ + 2(\log(\hat{y}_i/y_i) + y_i/\hat{y}_i - 1), & \text{for }p=2\text{ (Gamma)}\\ + 2\left(\frac{\max(y_i,0)^{2-p}}{(1-p)(2-p)}- + \frac{y\,\hat{y}^{1-p}_i}{1-p}+\frac{\hat{y}^{2-p}_i}{2-p}\right), + & \text{otherwise} + \end{cases} + +Tweedie deviance is a homogeneous function of degree ``2-p``. +Thus, Gamma distribution with `p=2` means that simultaneously scaling `y_true` +and `y_pred` has no effect on the deviance. For Poisson distribution `p=1` +the deviance scales linearly, and for Normal distribution (`p=0`), +quadratically. In general, the higher `p` the less weight is given to extreme +deviations between true and predicted targets. + +For instance, let's compare the two predictions 1.0 and 100 that are both +50% of their corresponding true value. + +The mean squared error (``p=0``) is very sensitive to the +prediction difference of the second point,:: + + >>> from sklearn.metrics import mean_tweedie_deviance + >>> mean_tweedie_deviance([1.0], [1.5], p=0) + 0.25 + >>> mean_tweedie_deviance([100.], [150.], p=0) + 2500.0 + +If we increase ``p`` to 1,:: + + >>> mean_tweedie_deviance([1.0], [1.5], p=1) + 0.18... + >>> mean_tweedie_deviance([100.], [150.], p=1) + 18.9... + +the difference in errors decreases. Finally, by setting, ``p=2``:: + + >>> mean_tweedie_deviance([1.0], [1.5], p=2) + 0.14... + >>> mean_tweedie_deviance([100.], [150.], p=2) + 0.14... + +we would get identical errors. The deviance when `p=2` is thus only +sensitive to relative errors. + .. _clustering_metrics: Clustering metrics diff --git a/doc/whats_new/v0.22.rst b/doc/whats_new/v0.22.rst index f2046cc6b64f1..527db6432462e 100644 --- a/doc/whats_new/v0.22.rst +++ b/doc/whats_new/v0.22.rst @@ -124,6 +124,14 @@ Changelog - |Feature| Added multiclass support to :func:`metrics.roc_auc_score`. :issue:`12789` by :user:`Kathy Chen <kathyxchen>`, :user:`Mohamed Maskani <maskani-moh>`, and :user:`Thomas Fan <thomasjpfan>`. + +- |Feature| Add :class:`metrics.mean_tweedie_deviance` measuring the + Tweedie deviance for a power parameter ``p``. Also add mean Poisson deviance + :class:`metrics.mean_poisson_deviance` and mean Gamma deviance + :class:`metrics.mean_gamma_deviance` that are special cases of the Tweedie + deviance for `p=1` and `p=2` respectively. + :pr:`13938` by :user:`Christian Lorentzen <lorentzenchr>` and + `Roman Yurchak`_. :mod:`sklearn.model_selection` .................. diff --git a/sklearn/metrics/__init__.py b/sklearn/metrics/__init__.py index 61ac2e5be4807..6f16713161f12 100644 --- a/sklearn/metrics/__init__.py +++ b/sklearn/metrics/__init__.py @@ -64,6 +64,9 @@ from .regression import mean_squared_log_error from .regression import median_absolute_error from .regression import r2_score +from .regression import mean_tweedie_deviance +from .regression import mean_poisson_deviance +from .regression import mean_gamma_deviance from .scorer import check_scoring @@ -110,6 +113,9 @@ 'mean_absolute_error', 'mean_squared_error', 'mean_squared_log_error', + 'mean_poisson_deviance', + 'mean_gamma_deviance', + 'mean_tweedie_deviance', 'median_absolute_error', 'multilabel_confusion_matrix', 'mutual_info_score', diff --git a/sklearn/metrics/regression.py b/sklearn/metrics/regression.py index bee377f132cf7..2cba3d31ec84a 100644 --- a/sklearn/metrics/regression.py +++ b/sklearn/metrics/regression.py @@ -19,10 +19,12 @@ # Manoj Kumar <manojkumarsivaraj334@gmail.com> # Michael Eickenberg <michael.eickenberg@gmail.com> # Konstantin Shmelkov <konstantin.shmelkov@polytechnique.edu> +# Christian Lorentzen <lorentzen.ch@googlemail.com> # License: BSD 3 clause import numpy as np +from scipy.special import xlogy import warnings from ..utils.validation import (check_array, check_consistent_length, @@ -38,11 +40,14 @@ "mean_squared_log_error", "median_absolute_error", "r2_score", - "explained_variance_score" + "explained_variance_score", + "mean_tweedie_deviance", + "mean_poisson_deviance", + "mean_gamma_deviance", ] -def _check_reg_targets(y_true, y_pred, multioutput): +def _check_reg_targets(y_true, y_pred, multioutput, dtype="numeric"): """Check that y_true and y_pred belong to the same regression task Parameters @@ -72,11 +77,13 @@ def _check_reg_targets(y_true, y_pred, multioutput): Custom output weights if ``multioutput`` is array-like or just the corresponding argument if ``multioutput`` is a correct keyword. + dtype: str or list, default="numeric" + the dtype argument passed to check_array """ check_consistent_length(y_true, y_pred) - y_true = check_array(y_true, ensure_2d=False) - y_pred = check_array(y_pred, ensure_2d=False) + y_true = check_array(y_true, ensure_2d=False, dtype=dtype) + y_pred = check_array(y_pred, ensure_2d=False, dtype=dtype) if y_true.ndim == 1: y_true = y_true.reshape((-1, 1)) @@ -609,3 +616,179 @@ def max_error(y_true, y_pred): if y_type == 'continuous-multioutput': raise ValueError("Multioutput not supported in max_error") return np.max(np.abs(y_true - y_pred)) + + +def mean_tweedie_deviance(y_true, y_pred, sample_weight=None, p=0): + """Mean Tweedie deviance regression loss. + + Read more in the :ref:`User Guide <mean_tweedie_deviance>`. + + Parameters + ---------- + y_true : array-like of shape (n_samples,) + Ground truth (correct) target values. + + y_pred : array-like of shape (n_samples,) + Estimated target values. + + sample_weight : array-like, shape (n_samples,), optional + Sample weights. + + p : float, optional + Tweedie power parameter. Either p ≤ 0 or p ≥ 1. + + The higher `p` the less weight is given to extreme + deviations between true and predicted targets. + + - p < 0: Extreme stable distribution. Requires: y_pred > 0. + - p = 0 : Normal distribution, output corresponds to + mean_squared_error. y_true and y_pred can be any real numbers. + - p = 1 : Poisson distribution. Requires: y_true ≥ 0 and y_pred > 0. + - 1 < p < 2 : Compound Poisson distribution. Requires: y_true ≥ 0 + and y_pred > 0. + - p = 2 : Gamma distribution. Requires: y_true > 0 and y_pred > 0. + - p = 3 : Inverse Gaussian distribution. Requires: y_true > 0 + and y_pred > 0. + - otherwise : Positive stable distribution. Requires: y_true > 0 + and y_pred > 0. + + Returns + ------- + loss : float + A non-negative floating point value (the best value is 0.0). + + Examples + -------- + >>> from sklearn.metrics import mean_tweedie_deviance + >>> y_true = [2, 0, 1, 4] + >>> y_pred = [0.5, 0.5, 2., 2.] + >>> mean_tweedie_deviance(y_true, y_pred, p=1) + 1.4260... + """ + y_type, y_true, y_pred, _ = _check_reg_targets( + y_true, y_pred, None, dtype=[np.float64, np.float32]) + if y_type == 'continuous-multioutput': + raise ValueError("Multioutput not supported in mean_tweedie_deviance") + check_consistent_length(y_true, y_pred, sample_weight) + + if sample_weight is not None: + sample_weight = column_or_1d(sample_weight) + sample_weight = sample_weight[:, np.newaxis] + + message = ("Mean Tweedie deviance error with p={} can only be used on " + .format(p)) + if p < 0: + # 'Extreme stable', y_true any realy number, y_pred > 0 + if (y_pred <= 0).any(): + raise ValueError(message + "strictly positive y_pred.") + dev = 2 * (np.power(np.maximum(y_true, 0), 2-p)/((1-p) * (2-p)) - + y_true * np.power(y_pred, 1-p)/(1-p) + + np.power(y_pred, 2-p)/(2-p)) + elif p == 0: + # Normal distribution, y_true and y_pred any real number + dev = (y_true - y_pred)**2 + elif p < 1: + raise ValueError("Tweedie deviance is only defined for p<=0 and " + "p>=1.") + elif p == 1: + # Poisson distribution, y_true >= 0, y_pred > 0 + if (y_true < 0).any() or (y_pred <= 0).any(): + raise ValueError(message + "non-negative y_true and strictly " + "positive y_pred.") + dev = 2 * (xlogy(y_true, y_true/y_pred) - y_true + y_pred) + elif p == 2: + # Gamma distribution, y_true and y_pred > 0 + if (y_true <= 0).any() or (y_pred <= 0).any(): + raise ValueError(message + "strictly positive y_true and y_pred.") + dev = 2 * (np.log(y_pred/y_true) + y_true/y_pred - 1) + else: + if p < 2: + # 1 < p < 2 is Compound Poisson, y_true >= 0, y_pred > 0 + if (y_true < 0).any() or (y_pred <= 0).any(): + raise ValueError(message + "non-negative y_true and strictly " + "positive y_pred.") + else: + if (y_true <= 0).any() or (y_pred <= 0).any(): + raise ValueError(message + "strictly positive y_true and " + "y_pred.") + + dev = 2 * (np.power(y_true, 2-p)/((1-p) * (2-p)) - + y_true * np.power(y_pred, 1-p)/(1-p) + + np.power(y_pred, 2-p)/(2-p)) + + return np.average(dev, weights=sample_weight) + + +def mean_poisson_deviance(y_true, y_pred, sample_weight=None): + """Mean Poisson deviance regression loss. + + Poisson deviance is equivalent to the Tweedie deviance with + the power parameter `p=1`. + + Read more in the :ref:`User Guide <mean_tweedie_deviance>`. + + Parameters + ---------- + y_true : array-like of shape (n_samples,) + Ground truth (correct) target values. Requires y_true ≥ 0. + + y_pred : array-like of shape (n_samples,) + Estimated target values. Requires y_pred > 0. + + sample_weight : array-like, shape (n_samples,), optional + Sample weights. + + Returns + ------- + loss : float + A non-negative floating point value (the best value is 0.0). + + Examples + -------- + >>> from sklearn.metrics import mean_poisson_deviance + >>> y_true = [2, 0, 1, 4] + >>> y_pred = [0.5, 0.5, 2., 2.] + >>> mean_poisson_deviance(y_true, y_pred) + 1.4260... + """ + return mean_tweedie_deviance( + y_true, y_pred, sample_weight=sample_weight, p=1 + ) + + +def mean_gamma_deviance(y_true, y_pred, sample_weight=None): + """Mean Gamma deviance regression loss. + + Gamma deviance is equivalent to the Tweedie deviance with + the power parameter `p=2`. It is invariant to scaling of + the target variable, and mesures relative errors. + + Read more in the :ref:`User Guide <mean_tweedie_deviance>`. + + Parameters + ---------- + y_true : array-like of shape (n_samples,) + Ground truth (correct) target values. Requires y_true > 0. + + y_pred : array-like of shape (n_samples,) + Estimated target values. Requires y_pred > 0. + + sample_weight : array-like, shape (n_samples,), optional + Sample weights. + + Returns + ------- + loss : float + A non-negative floating point value (the best value is 0.0). + + Examples + -------- + >>> from sklearn.metrics import mean_gamma_deviance + >>> y_true = [2, 0.5, 1, 4] + >>> y_pred = [0.5, 0.5, 2., 2.] + >>> mean_gamma_deviance(y_true, y_pred) + 1.0568... + """ + return mean_tweedie_deviance( + y_true, y_pred, sample_weight=sample_weight, p=2 + ) diff --git a/sklearn/metrics/scorer.py b/sklearn/metrics/scorer.py index 9fe3ad9fba4e1..5d543a305239b 100644 --- a/sklearn/metrics/scorer.py +++ b/sklearn/metrics/scorer.py @@ -24,7 +24,8 @@ import numpy as np from . import (r2_score, median_absolute_error, max_error, mean_absolute_error, - mean_squared_error, mean_squared_log_error, accuracy_score, + mean_squared_error, mean_squared_log_error, + mean_tweedie_deviance, accuracy_score, f1_score, roc_auc_score, average_precision_score, precision_score, recall_score, log_loss, balanced_accuracy_score, explained_variance_score, @@ -492,9 +493,15 @@ def make_scorer(score_func, greater_is_better=True, needs_proba=False, greater_is_better=False) neg_mean_absolute_error_scorer = make_scorer(mean_absolute_error, greater_is_better=False) - neg_median_absolute_error_scorer = make_scorer(median_absolute_error, greater_is_better=False) +neg_mean_poisson_deviance_scorer = make_scorer( + mean_tweedie_deviance, p=1., greater_is_better=False +) + +neg_mean_gamma_deviance_scorer = make_scorer( + mean_tweedie_deviance, p=2., greater_is_better=False +) # Standard Classification Scores accuracy_scorer = make_scorer(accuracy_score) @@ -542,6 +549,8 @@ def make_scorer(score_func, greater_is_better=True, needs_proba=False, neg_mean_absolute_error=neg_mean_absolute_error_scorer, neg_mean_squared_error=neg_mean_squared_error_scorer, neg_mean_squared_log_error=neg_mean_squared_log_error_scorer, + neg_mean_poisson_deviance=neg_mean_poisson_deviance_scorer, + neg_mean_gamma_deviance=neg_mean_gamma_deviance_scorer, accuracy=accuracy_scorer, roc_auc=roc_auc_scorer, roc_auc_ovr=roc_auc_ovr_scorer, roc_auc_ovo=roc_auc_ovo_scorer,

diff --git a/sklearn/metrics/tests/test_common.py b/sklearn/metrics/tests/test_common.py index 6442b11834671..8d62caa8a16c6 100644 --- a/sklearn/metrics/tests/test_common.py +++ b/sklearn/metrics/tests/test_common.py @@ -44,6 +44,9 @@ from sklearn.metrics import matthews_corrcoef from sklearn.metrics import mean_absolute_error from sklearn.metrics import mean_squared_error +from sklearn.metrics import mean_tweedie_deviance +from sklearn.metrics import mean_poisson_deviance +from sklearn.metrics import mean_gamma_deviance from sklearn.metrics import median_absolute_error from sklearn.metrics import multilabel_confusion_matrix from sklearn.metrics import precision_recall_curve @@ -97,6 +100,11 @@ "median_absolute_error": median_absolute_error, "explained_variance_score": explained_variance_score, "r2_score": partial(r2_score, multioutput='variance_weighted'), + "mean_normal_deviance": partial(mean_tweedie_deviance, p=0), + "mean_poisson_deviance": mean_poisson_deviance, + "mean_gamma_deviance": mean_gamma_deviance, + "mean_compound_poisson_deviance": + partial(mean_tweedie_deviance, p=1.4), } CLASSIFICATION_METRICS = { @@ -434,7 +442,7 @@ def precision_recall_curve_padded_thresholds(*args, **kwargs): "matthews_corrcoef_score", "mean_absolute_error", "mean_squared_error", "median_absolute_error", "max_error", - "cohen_kappa_score", + "cohen_kappa_score", "mean_normal_deviance" } # Asymmetric with respect to their input arguments y_true and y_pred @@ -456,7 +464,9 @@ def precision_recall_curve_padded_thresholds(*args, **kwargs): "unnormalized_multilabel_confusion_matrix", "macro_f0.5_score", "macro_f2_score", "macro_precision_score", - "macro_recall_score", "log_loss", "hinge_loss" + "macro_recall_score", "log_loss", "hinge_loss", + "mean_gamma_deviance", "mean_poisson_deviance", + "mean_compound_poisson_deviance" } @@ -468,16 +478,22 @@ def precision_recall_curve_padded_thresholds(*args, **kwargs): "weighted_ovo_roc_auc" } +METRICS_REQUIRE_POSITIVE_Y = { + "mean_poisson_deviance", + "mean_gamma_deviance", + "mean_compound_poisson_deviance", +} -@ignore_warnings -def test_symmetry(): - # Test the symmetry of score and loss functions - random_state = check_random_state(0) - y_true = random_state.randint(0, 2, size=(20, )) - y_pred = random_state.randint(0, 2, size=(20, )) - y_true_bin = random_state.randint(0, 2, size=(20, 25)) - y_pred_bin = random_state.randint(0, 2, size=(20, 25)) +def _require_positive_targets(y1, y2): + """Make targets strictly positive""" + offset = abs(min(y1.min(), y2.min())) + 1 + y1 += offset + y2 += offset + return y1, y2 + + +def test_symmetry_consistency(): # We shouldn't forget any metrics assert (SYMMETRIC_METRICS.union( @@ -489,29 +505,50 @@ def test_symmetry(): SYMMETRIC_METRICS.intersection(NOT_SYMMETRIC_METRICS) == set()) - # Symmetric metric - for name in SYMMETRIC_METRICS: - metric = ALL_METRICS[name] - if name in METRIC_UNDEFINED_BINARY: - if name in MULTILABELS_METRICS: - assert_allclose(metric(y_true_bin, y_pred_bin), - metric(y_pred_bin, y_true_bin), - err_msg="%s is not symmetric" % name) - else: - assert False, "This case is currently unhandled" - else: - assert_allclose(metric(y_true, y_pred), - metric(y_pred, y_true), + +@pytest.mark.parametrize("name", sorted(SYMMETRIC_METRICS)) +def test_symmetric_metric(name): + # Test the symmetry of score and loss functions + random_state = check_random_state(0) + y_true = random_state.randint(0, 2, size=(20, )) + y_pred = random_state.randint(0, 2, size=(20, )) + + if name in METRICS_REQUIRE_POSITIVE_Y: + y_true, y_pred = _require_positive_targets(y_true, y_pred) + + y_true_bin = random_state.randint(0, 2, size=(20, 25)) + y_pred_bin = random_state.randint(0, 2, size=(20, 25)) + + metric = ALL_METRICS[name] + if name in METRIC_UNDEFINED_BINARY: + if name in MULTILABELS_METRICS: + assert_allclose(metric(y_true_bin, y_pred_bin), + metric(y_pred_bin, y_true_bin), err_msg="%s is not symmetric" % name) + else: + assert False, "This case is currently unhandled" + else: + assert_allclose(metric(y_true, y_pred), + metric(y_pred, y_true), + err_msg="%s is not symmetric" % name) - # Not symmetric metrics - for name in NOT_SYMMETRIC_METRICS: - metric = ALL_METRICS[name] - # use context manager to supply custom error message - with assert_raises(AssertionError) as cm: - assert_array_equal(metric(y_true, y_pred), metric(y_pred, y_true)) - cm.msg = ("%s seems to be symmetric" % name) +@pytest.mark.parametrize("name", sorted(NOT_SYMMETRIC_METRICS)) +def test_not_symmetric_metric(name): + # Test the symmetry of score and loss functions + random_state = check_random_state(0) + y_true = random_state.randint(0, 2, size=(20, )) + y_pred = random_state.randint(0, 2, size=(20, )) + + if name in METRICS_REQUIRE_POSITIVE_Y: + y_true, y_pred = _require_positive_targets(y_true, y_pred) + + metric = ALL_METRICS[name] + + # use context manager to supply custom error message + with assert_raises(AssertionError) as cm: + assert_array_equal(metric(y_true, y_pred), metric(y_pred, y_true)) + cm.msg = ("%s seems to be symmetric" % name) @pytest.mark.parametrize( @@ -521,6 +558,9 @@ def test_sample_order_invariance(name): random_state = check_random_state(0) y_true = random_state.randint(0, 2, size=(20, )) y_pred = random_state.randint(0, 2, size=(20, )) + if name in METRICS_REQUIRE_POSITIVE_Y: + y_true, y_pred = _require_positive_targets(y_true, y_pred) + y_true_shuffle, y_pred_shuffle = shuffle(y_true, y_pred, random_state=0) with ignore_warnings(): @@ -574,6 +614,9 @@ def test_format_invariance_with_1d_vectors(name): y1 = random_state.randint(0, 2, size=(20, )) y2 = random_state.randint(0, 2, size=(20, )) + if name in METRICS_REQUIRE_POSITIVE_Y: + y1, y2 = _require_positive_targets(y1, y2) + y1_list = list(y1) y2_list = list(y2) @@ -762,7 +805,11 @@ def check_single_sample(name): metric = ALL_METRICS[name] # assert that no exception is thrown - for i, j in product([0, 1], repeat=2): + if name in METRICS_REQUIRE_POSITIVE_Y: + values = [1, 2] + else: + values = [0, 1] + for i, j in product(values, repeat=2): metric([i], [j]) diff --git a/sklearn/metrics/tests/test_regression.py b/sklearn/metrics/tests/test_regression.py index bc4cacb62e8d7..526c27f0a036c 100644 --- a/sklearn/metrics/tests/test_regression.py +++ b/sklearn/metrics/tests/test_regression.py @@ -1,5 +1,6 @@ import numpy as np +from numpy.testing import assert_allclose from itertools import product import pytest @@ -15,6 +16,7 @@ from sklearn.metrics import median_absolute_error from sklearn.metrics import max_error from sklearn.metrics import r2_score +from sklearn.metrics import mean_tweedie_deviance from sklearn.metrics.regression import _check_reg_targets @@ -34,6 +36,25 @@ def test_regression_metrics(n_samples=50): assert_almost_equal(max_error(y_true, y_pred), 1.) assert_almost_equal(r2_score(y_true, y_pred), 0.995, 2) assert_almost_equal(explained_variance_score(y_true, y_pred), 1.) + assert_almost_equal(mean_tweedie_deviance(y_true, y_pred, p=0), + mean_squared_error(y_true, y_pred)) + + # Tweedie deviance needs positive y_pred, except for p=0, + # p>=2 needs positive y_true + # results evaluated by sympy + y_true = np.arange(1, 1 + n_samples) + y_pred = 2 * y_true + n = n_samples + assert_almost_equal(mean_tweedie_deviance(y_true, y_pred, p=-1), + 5/12 * n * (n**2 + 2 * n + 1)) + assert_almost_equal(mean_tweedie_deviance(y_true, y_pred, p=1), + (n + 1) * (1 - np.log(2))) + assert_almost_equal(mean_tweedie_deviance(y_true, y_pred, p=2), + 2 * np.log(2) - 1) + assert_almost_equal(mean_tweedie_deviance(y_true, y_pred, p=3/2), + ((6 * np.sqrt(2) - 8) / n) * np.sqrt(y_true).sum()) + assert_almost_equal(mean_tweedie_deviance(y_true, y_pred, p=3), + np.sum(1 / y_true) / (4 * n)) def test_multioutput_regression(): @@ -75,6 +96,42 @@ def test_regression_metrics_at_limits(): "used when targets contain negative values.", mean_squared_log_error, [1., -2., 3.], [1., 2., 3.]) + # Tweedie deviance error + p = -1.2 + assert_allclose(mean_tweedie_deviance([0], [1.], p=p), + 2./(2.-p), rtol=1e-3) + with pytest.raises(ValueError, + match="can only be used on strictly positive y_pred."): + mean_tweedie_deviance([0.], [0.], p=p) + assert_almost_equal(mean_tweedie_deviance([0.], [0.], p=0), 0.00, 2) + + msg = "only be used on non-negative y_true and strictly positive y_pred." + with pytest.raises(ValueError, match=msg): + mean_tweedie_deviance([0.], [0.], p=1.0) + + p = 1.5 + assert_allclose(mean_tweedie_deviance([0.], [1.], p=p), 2./(2.-p)) + msg = "only be used on non-negative y_true and strictly positive y_pred." + with pytest.raises(ValueError, match=msg): + mean_tweedie_deviance([0.], [0.], p=p) + p = 2. + assert_allclose(mean_tweedie_deviance([1.], [1.], p=p), 0.00, + atol=1e-8) + msg = "can only be used on strictly positive y_true and y_pred." + with pytest.raises(ValueError, match=msg): + mean_tweedie_deviance([0.], [0.], p=p) + p = 3. + assert_allclose(mean_tweedie_deviance([1.], [1.], p=p), + 0.00, atol=1e-8) + + msg = "can only be used on strictly positive y_true and y_pred." + with pytest.raises(ValueError, match=msg): + mean_tweedie_deviance([0.], [0.], p=p) + + with pytest.raises(ValueError, + match="deviance is only defined for p<=0 and p>=1."): + mean_tweedie_deviance([0.], [0.], p=0.5) + def test__check_reg_targets(): # All of length 3 @@ -202,3 +259,29 @@ def test_regression_single_sample(metric): with pytest.warns(UndefinedMetricWarning, match=warning_msg): score = metric(y_true, y_pred) assert np.isnan(score) + + +def test_tweedie_deviance_continuity(): + n_samples = 100 + + y_true = np.random.RandomState(0).rand(n_samples) + 0.1 + y_pred = np.random.RandomState(1).rand(n_samples) + 0.1 + + assert_allclose(mean_tweedie_deviance(y_true, y_pred, p=0 - 1e-10), + mean_tweedie_deviance(y_true, y_pred, p=0)) + + # Ws we get closer to the limit, with 1e-12 difference the absolute + # tolerance to pass the below check increases. There are likely + # numerical precision issues on the edges of different definition + # regions. + assert_allclose(mean_tweedie_deviance(y_true, y_pred, p=1 + 1e-10), + mean_tweedie_deviance(y_true, y_pred, p=1), + atol=1e-6) + + assert_allclose(mean_tweedie_deviance(y_true, y_pred, p=2 - 1e-10), + mean_tweedie_deviance(y_true, y_pred, p=2), + atol=1e-6) + + assert_allclose(mean_tweedie_deviance(y_true, y_pred, p=2 + 1e-10), + mean_tweedie_deviance(y_true, y_pred, p=2), + atol=1e-6) diff --git a/sklearn/metrics/tests/test_score_objects.py b/sklearn/metrics/tests/test_score_objects.py index f7d41eda0075c..e4300125f57a3 100644 --- a/sklearn/metrics/tests/test_score_objects.py +++ b/sklearn/metrics/tests/test_score_objects.py @@ -43,7 +43,8 @@ 'neg_mean_squared_log_error', 'neg_median_absolute_error', 'mean_absolute_error', 'mean_squared_error', 'median_absolute_error', - 'max_error'] + 'max_error', 'neg_mean_poisson_deviance', + 'neg_mean_gamma_deviance'] CLF_SCORERS = ['accuracy', 'balanced_accuracy', 'f1', 'f1_weighted', 'f1_macro', 'f1_micro', @@ -67,11 +68,22 @@ MULTILABEL_ONLY_SCORERS = ['precision_samples', 'recall_samples', 'f1_samples', 'jaccard_samples'] +REQUIRE_POSITIVE_Y_SCORERS = ['neg_mean_poisson_deviance', + 'neg_mean_gamma_deviance'] + + +def _require_positive_y(y): + """Make targets strictly positive""" + offset = abs(y.min()) + 1 + y = y + offset + return y + def _make_estimators(X_train, y_train, y_ml_train): # Make estimators that make sense to test various scoring methods sensible_regr = DecisionTreeRegressor(random_state=0) - sensible_regr.fit(X_train, y_train) + # some of the regressions scorers require strictly positive input. + sensible_regr.fit(X_train, y_train + 1) sensible_clf = DecisionTreeClassifier(random_state=0) sensible_clf.fit(X_train, y_train) sensible_ml_clf = DecisionTreeClassifier(random_state=0) @@ -477,6 +489,8 @@ def test_scorer_sample_weight(): target = y_ml_test else: target = y_test + if name in REQUIRE_POSITIVE_Y_SCORERS: + target = _require_positive_y(target) try: weighted = scorer(estimator[name], X_test, target, sample_weight=sample_weight) @@ -498,22 +512,26 @@ def test_scorer_sample_weight(): "with sample weights: {1}".format(name, str(e))) -@ignore_warnings # UndefinedMetricWarning for P / R scores -def check_scorer_memmap(scorer_name): - scorer, estimator = SCORERS[scorer_name], ESTIMATORS[scorer_name] - if scorer_name in MULTILABEL_ONLY_SCORERS: - score = scorer(estimator, X_mm, y_ml_mm) - else: - score = scorer(estimator, X_mm, y_mm) - assert isinstance(score, numbers.Number), scorer_name - - @pytest.mark.parametrize('name', SCORERS) def test_scorer_memmap_input(name): # Non-regression test for #6147: some score functions would # return singleton memmap when computed on memmap data instead of scalar # float values. - check_scorer_memmap(name) + + if name in REQUIRE_POSITIVE_Y_SCORERS: + y_mm_1 = _require_positive_y(y_mm) + y_ml_mm_1 = _require_positive_y(y_ml_mm) + else: + y_mm_1, y_ml_mm_1 = y_mm, y_ml_mm + + # UndefinedMetricWarning for P / R scores + with ignore_warnings(): + scorer, estimator = SCORERS[name], ESTIMATORS[name] + if name in MULTILABEL_ONLY_SCORERS: + score = scorer(estimator, X_mm, y_ml_mm_1) + else: + score = scorer(estimator, X_mm, y_mm_1) + assert isinstance(score, numbers.Number), name def test_scoring_is_not_metric():

diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 30fc3b5102bc6..ad290ef187aef 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -903,6 +903,9 @@ details. metrics.mean_squared_log_error metrics.median_absolute_error metrics.r2_score + metrics.mean_poisson_deviance + metrics.mean_gamma_deviance + metrics.mean_tweedie_deviance Multilabel ranking metrics -------------------------- diff --git a/doc/modules/model_evaluation.rst b/doc/modules/model_evaluation.rst index 789ffa038f25d..e28d35d985dd8 100644 --- a/doc/modules/model_evaluation.rst +++ b/doc/modules/model_evaluation.rst @@ -91,6 +91,8 @@ Scoring Function 'neg_mean_squared_log_error' :func:`metrics.mean_squared_log_error` 'neg_median_absolute_error' :func:`metrics.median_absolute_error` 'r2' :func:`metrics.r2_score` +'neg_mean_poisson_deviance' :func:`metrics.mean_poisson_deviance` +'neg_mean_gamma_deviance' :func:`metrics.mean_gamma_deviance` ============================== ============================================= ================================== @@ -1957,6 +1959,76 @@ Here is a small example of usage of the :func:`r2_score` function:: for an example of R² score usage to evaluate Lasso and Elastic Net on sparse signals. + +.. _mean_tweedie_deviance: + +Mean Poisson, Gamma, and Tweedie deviances +------------------------------------------ +The :func:`mean_tweedie_deviance` function computes the `mean Tweedie +deviance error +<https://en.wikipedia.org/wiki/Tweedie_distribution#The_Tweedie_deviance>`_ +with power parameter `p`. This is a metric that elicits predicted expectation +values of regression targets. + +Following special cases exist, + +- when `p=0` it is equivalent to :func:`mean_squared_error`. +- when `p=1` it is equivalent to :func:`mean_poisson_deviance`. +- when `p=2` it is equivalent to :func:`mean_gamma_deviance`. + +If :math:`\hat{y}_i` is the predicted value of the :math:`i`-th sample, +and :math:`y_i` is the corresponding true value, then the mean Tweedie +deviance error (D) estimated over :math:`n_{\text{samples}}` is defined as + +.. math:: + + \text{D}(y, \hat{y}) = \frac{1}{n_\text{samples}} + \sum_{i=0}^{n_\text{samples} - 1} + \begin{cases} + (y_i-\hat{y}_i)^2, & \text{for }p=0\text{ (Normal)}\\ + 2(y_i \log(y/\hat{y}_i) + \hat{y}_i - y_i), & \text{for }p=1\text{ (Poisson)}\\ + 2(\log(\hat{y}_i/y_i) + y_i/\hat{y}_i - 1), & \text{for }p=2\text{ (Gamma)}\\ + 2\left(\frac{\max(y_i,0)^{2-p}}{(1-p)(2-p)}- + \frac{y\,\hat{y}^{1-p}_i}{1-p}+\frac{\hat{y}^{2-p}_i}{2-p}\right), + & \text{otherwise} + \end{cases} + +Tweedie deviance is a homogeneous function of degree ``2-p``. +Thus, Gamma distribution with `p=2` means that simultaneously scaling `y_true` +and `y_pred` has no effect on the deviance. For Poisson distribution `p=1` +the deviance scales linearly, and for Normal distribution (`p=0`), +quadratically. In general, the higher `p` the less weight is given to extreme +deviations between true and predicted targets. + +For instance, let's compare the two predictions 1.0 and 100 that are both +50% of their corresponding true value. + +The mean squared error (``p=0``) is very sensitive to the +prediction difference of the second point,:: + + >>> from sklearn.metrics import mean_tweedie_deviance + >>> mean_tweedie_deviance([1.0], [1.5], p=0) + 0.25 + >>> mean_tweedie_deviance([100.], [150.], p=0) + 2500.0 + +If we increase ``p`` to 1,:: + + >>> mean_tweedie_deviance([1.0], [1.5], p=1) + 0.18... + >>> mean_tweedie_deviance([100.], [150.], p=1) + 18.9... + +the difference in errors decreases. Finally, by setting, ``p=2``:: + + >>> mean_tweedie_deviance([1.0], [1.5], p=2) + 0.14... + >>> mean_tweedie_deviance([100.], [150.], p=2) + 0.14... + +we would get identical errors. The deviance when `p=2` is thus only +sensitive to relative errors. + .. _clustering_metrics: Clustering metrics diff --git a/doc/whats_new/v0.22.rst b/doc/whats_new/v0.22.rst index f2046cc6b64f1..527db6432462e 100644 --- a/doc/whats_new/v0.22.rst +++ b/doc/whats_new/v0.22.rst @@ -124,6 +124,14 @@ Changelog - |Feature| Added multiclass support to :func:`metrics.roc_auc_score`. :issue:`12789` by :user:`Kathy Chen <kathyxchen>`, :user:`Mohamed Maskani <maskani-moh>`, and :user:`Thomas Fan <thomasjpfan>`. + +- |Feature| Add :class:`metrics.mean_tweedie_deviance` measuring the + Tweedie deviance for a power parameter ``p``. Also add mean Poisson deviance + :class:`metrics.mean_poisson_deviance` and mean Gamma deviance + :class:`metrics.mean_gamma_deviance` that are special cases of the Tweedie + deviance for `p=1` and `p=2` respectively. + :pr:`13938` by :user:`Christian Lorentzen <lorentzenchr>` and + `Roman Yurchak`_. :mod:`sklearn.model_selection` ..................

[ { "components": [ { "doc": "Mean Tweedie deviance regression loss.\n\nRead more in the :ref:`User Guide <mean_tweedie_deviance>`.\n\nParameters\n----------\ny_true : array-like of shape (n_samples,)\n Ground truth (correct) target values.\n\ny_pred : array-like of shape (n_samples,)\n Estima...

[ "sklearn/metrics/tests/test_common.py::test_symmetry_consistency", "sklearn/metrics/tests/test_common.py::test_symmetric_metric[accuracy_score]", "sklearn/metrics/tests/test_common.py::test_symmetric_metric[cohen_kappa_score]", "sklearn/metrics/tests/test_common.py::test_symmetric_metric[f1_score]", "sklear...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> ENH Add Poisson, Gamma and Tweedie deviances to regression metrics ### Reference Issues/PRs Contributes to #9405 #### What does this implement/fix? Adds new regression metrics that are natural for GLMs. ### Comments Name ‘mean_teeedie_deviance_error‘ open for discussion ;-) ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/metrics/regression.py] (definition of mean_tweedie_deviance:) def mean_tweedie_deviance(y_true, y_pred, sample_weight=None, p=0): """Mean Tweedie deviance regression loss. Read more in the :ref:`User Guide <mean_tweedie_deviance>`. Parameters ---------- y_true : array-like of shape (n_samples,) Ground truth (correct) target values. y_pred : array-like of shape (n_samples,) Estimated target values. sample_weight : array-like, shape (n_samples,), optional Sample weights. p : float, optional Tweedie power parameter. Either p ≤ 0 or p ≥ 1. The higher `p` the less weight is given to extreme deviations between true and predicted targets. - p < 0: Extreme stable distribution. Requires: y_pred > 0. - p = 0 : Normal distribution, output corresponds to mean_squared_error. y_true and y_pred can be any real numbers. - p = 1 : Poisson distribution. Requires: y_true ≥ 0 and y_pred > 0. - 1 < p < 2 : Compound Poisson distribution. Requires: y_true ≥ 0 and y_pred > 0. - p = 2 : Gamma distribution. Requires: y_true > 0 and y_pred > 0. - p = 3 : Inverse Gaussian distribution. Requires: y_true > 0 and y_pred > 0. - otherwise : Positive stable distribution. Requires: y_true > 0 and y_pred > 0. Returns ------- loss : float A non-negative floating point value (the best value is 0.0). Examples -------- >>> from sklearn.metrics import mean_tweedie_deviance >>> y_true = [2, 0, 1, 4] >>> y_pred = [0.5, 0.5, 2., 2.] >>> mean_tweedie_deviance(y_true, y_pred, p=1) 1.4260...""" (definition of mean_poisson_deviance:) def mean_poisson_deviance(y_true, y_pred, sample_weight=None): """Mean Poisson deviance regression loss. Poisson deviance is equivalent to the Tweedie deviance with the power parameter `p=1`. Read more in the :ref:`User Guide <mean_tweedie_deviance>`. Parameters ---------- y_true : array-like of shape (n_samples,) Ground truth (correct) target values. Requires y_true ≥ 0. y_pred : array-like of shape (n_samples,) Estimated target values. Requires y_pred > 0. sample_weight : array-like, shape (n_samples,), optional Sample weights. Returns ------- loss : float A non-negative floating point value (the best value is 0.0). Examples -------- >>> from sklearn.metrics import mean_poisson_deviance >>> y_true = [2, 0, 1, 4] >>> y_pred = [0.5, 0.5, 2., 2.] >>> mean_poisson_deviance(y_true, y_pred) 1.4260...""" (definition of mean_gamma_deviance:) def mean_gamma_deviance(y_true, y_pred, sample_weight=None): """Mean Gamma deviance regression loss. Gamma deviance is equivalent to the Tweedie deviance with the power parameter `p=2`. It is invariant to scaling of the target variable, and mesures relative errors. Read more in the :ref:`User Guide <mean_tweedie_deviance>`. Parameters ---------- y_true : array-like of shape (n_samples,) Ground truth (correct) target values. Requires y_true > 0. y_pred : array-like of shape (n_samples,) Estimated target values. Requires y_pred > 0. sample_weight : array-like, shape (n_samples,), optional Sample weights. Returns ------- loss : float A non-negative floating point value (the best value is 0.0). Examples -------- >>> from sklearn.metrics import mean_gamma_deviance >>> y_true = [2, 0.5, 1, 4] >>> y_pred = [0.5, 0.5, 2., 2.] >>> mean_gamma_deviance(y_true, y_pred) 1.0568...""" [end of new definitions in sklearn/metrics/regression.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c96e0958da46ebef482a4084cdda3285d5f5ad23

sympy__sympy-17153

17,153

sympy/sympy

1.5

40da07b3a8ca3b315aaf25ec4ac21dfe4364a097

2019-07-05T04:58:35Z

diff --git a/sympy/geometry/ellipse.py b/sympy/geometry/ellipse.py index 699064603461..2d56c2ad53bf 100644 --- a/sympy/geometry/ellipse.py +++ b/sympy/geometry/ellipse.py @@ -1336,6 +1336,7 @@ def vradius(self): """ return self.args[2] + def second_moment_of_area(self, point=None): """Returns the second moment and product moment area of an ellipse. @@ -1385,6 +1386,98 @@ def second_moment_of_area(self, point=None): return I_xx, I_yy, I_xy + def polar_second_moment_of_area(self): + """Returns the polar second moment of area of an Ellipse + + It is a constituent of the second moment of area, linked through + the perpendicular axis theorem. While the planar second moment of + area describes an object's resistance to deflection (bending) when + subjected to a force applied to a plane parallel to the central + axis, the polar second moment of area describes an object's + resistance to deflection when subjected to a moment applied in a + plane perpendicular to the object's central axis (i.e. parallel to + the cross-section) + + References + ========== + + https://en.wikipedia.org/wiki/Polar_moment_of_inertia + + Examples + ======== + + >>> from sympy import symbols, Circle, Ellipse + >>> c = Circle((5, 5), 4) + >>> c.polar_second_moment_of_area() + 128*pi + >>> a, b = symbols('a, b') + >>> e = Ellipse((0, 0), a, b) + >>> e.polar_second_moment_of_area() + pi*a**3*b/4 + pi*a*b**3/4 + """ + second_moment = self.second_moment_of_area() + return second_moment[0] + second_moment[1] + + + def section_modulus(self, point=None): + """Returns a tuple with the section modulus of an ellipse + + Section modulus is a geometric property of an ellipse defined as the + ratio of second moment of area to the distance of the extreme end of + the ellipse from the centroidal axis. + + References + ========== + + https://en.wikipedia.org/wiki/Section_modulus + + Parameters + ========== + + point : Point, two-tuple of sympifyable objects, or None(default=None) + point is the point at which section modulus is to be found. + If "point=None" section modulus will be calculated for the + point farthest from the centroidal axis of the ellipse. + + Returns + ======= + + S_x, S_y: numbers or SymPy expressions + S_x is the section modulus with respect to the x-axis + S_y is the section modulus with respect to the y-axis + A negetive sign indicates that the section modulus is + determined for a point below the centroidal axis. + + Examples + ======== + + >>> from sympy import Symbol, Ellipse, Circle, Point2D + >>> d = Symbol('d', positive=True) + >>> c = Circle((0, 0), d/2) + >>> c.section_modulus() + (pi*d**3/32, pi*d**3/32) + >>> e = Ellipse(Point2D(0, 0), 2, 4) + >>> e.section_modulus() + (8*pi, 4*pi) + """ + x_c, y_c = self.center + if point is None: + # taking x and y as maximum distances from centroid + x_min, y_min, x_max, y_max = self.bounds + y = max(y_c - y_min, y_max - y_c) + x = max(x_c - x_min, x_max - x_c) + else: + # taking x and y as distances of the given point from the center + y = point.y - y_c + x = point.x - x_c + + second_moment = self.second_moment_of_area() + S_x = second_moment[0]/y + S_y = second_moment[1]/x + + return S_x, S_y + + class Circle(Ellipse): """A circle in space. diff --git a/sympy/geometry/polygon.py b/sympy/geometry/polygon.py index 8dde50d1d0e4..3d7973c6fd85 100644 --- a/sympy/geometry/polygon.py +++ b/sympy/geometry/polygon.py @@ -381,7 +381,7 @@ def second_moment_of_area(self, point=None): Parameters ========== - point : Point, two-tuple of sympifiable objects, or None(default=None) + point : Point, two-tuple of sympifyable objects, or None(default=None) point is the point about which second moment of area is to be found. If "point=None" it will be calculated about the axis passing through the centroid of the polygon. @@ -413,7 +413,7 @@ def second_moment_of_area(self, point=None): """ I_xx, I_yy, I_xy = 0, 0, 0 - args = self.args + args = self.vertices for i in range(len(args)): x1, y1 = args[i-1].args x2, y2 = args[i].args @@ -438,6 +438,166 @@ def second_moment_of_area(self, point=None): return I_xx, I_yy, I_xy + def first_moment_of_area(self, point=None): + """ + Returns the first moment of area of a two-dimensional polygon with + respect to a certain point of interest. + + First moment of area is a measure of the distribution of the area + of a polygon in relation to an axis. The first moment of area of + the entire polygon about its own centroid is always zero. Therefore, + here it is calculated for an area, above or below a certain point + of interest, that makes up a smaller portion of the polygon. This + area is bounded by the point of interest and the extreme end + (top or bottom) of the polygon. The first moment for this area is + is then determined about the centroidal axis of the initial polygon. + + References + ========== + + https://skyciv.com/docs/tutorials/section-tutorials/calculating-the-statical-or-first-moment-of-area-of-beam-sections/?cc=BMD + https://mechanicalc.com/reference/cross-sections + + Parameters + ========== + + point: Point, two-tuple of sympifyable objects, or None (default=None) + point is the point above or below which the area of interest lies + If ``point=None`` then the centroid acts as the point of interest. + + Returns + ======= + + Q_x, Q_y: number or sympy expressions + Q_x is the first moment of area about the x-axis + Q_y is the first moment of area about the y-axis + A negetive sign indicates that the section modulus is + determined for a section below (or left of) the centroidal axis + + Examples + ======== + + >>> from sympy import Point, Polygon, symbol + >>> a, b = 50, 10 + >>> p1, p2, p3, p4 = [(0, b), (0, 0), (a, 0), (a, b)] + >>> p = Polygon(p1, p2, p3, p4) + >>> p.first_moment_of_area() + (625, 3125) + >>> p.first_moment_of_area(point=Point(30, 7)) + (525, 3000) + """ + if point: + xc, yc = self.centroid + else: + point = self.centroid + xc, yc = point + + h_line = Line(point, slope=0) + v_line = Line(point, slope=S.Infinity) + + h_poly = self.cut_section(h_line) + v_poly = self.cut_section(v_line) + + x_min, y_min, x_max, y_max = self.bounds + + poly_1 = h_poly[0] if h_poly[0].area <= h_poly[1].area else h_poly[1] + poly_2 = v_poly[0] if v_poly[0].area <= v_poly[1].area else v_poly[1] + + Q_x = (poly_1.centroid.y - yc)*poly_1.area + Q_y = (poly_2.centroid.x - xc)*poly_2.area + + return Q_x, Q_y + + + def polar_second_moment_of_area(self): + """Returns the polar modulus of a two-dimensional polygon + + It is a constituent of the second moment of area, linked through + the perpendicular axis theorem. While the planar second moment of + area describes an object's resistance to deflection (bending) when + subjected to a force applied to a plane parallel to the central + axis, the polar second moment of area describes an object's + resistance to deflection when subjected to a moment applied in a + plane perpendicular to the object's central axis (i.e. parallel to + the cross-section) + + References + ========== + + https://en.wikipedia.org/wiki/Polar_moment_of_inertia + + Examples + ======== + + >>> from sympy import Polygon, symbols + >>> a, b = symbols('a, b') + >>> rectangle = Polygon((0, 0), (a, 0), (a, b), (0, b)) + >>> rectangle.polar_second_moment_of_area() + a**3*b/12 + a*b**3/12 + """ + second_moment = self.second_moment_of_area() + return second_moment[0] + second_moment[1] + + + def section_modulus(self, point=None): + """Returns a tuple with the section modulus of a two-dimensional + polygon. + + Section modulus is a geometric property of a polygon defined as the + ratio of second moment of area to the distance of the extreme end of + the polygon from the centroidal axis. + + References + ========== + + https://en.wikipedia.org/wiki/Section_modulus + + Parameters + ========== + + point : Point, two-tuple of sympifyable objects, or None(default=None) + point is the point at which section modulus is to be found. + If "point=None" it will be calculated for the point farthest from the + centroidal axis of the polygon. + + Returns + ======= + + S_x, S_y: numbers or SymPy expressions + S_x is the section modulus with respect to the x-axis + S_y is the section modulus with respect to the y-axis + A negetive sign indicates that the section modulus is + determined for a point below the centroidal axis + + Examples + ======== + + >>> from sympy import symbols, Polygon, Point + >>> a, b = symbols('a, b', positive=True) + >>> rectangle = Polygon((0, 0), (a, 0), (a, b), (0, b)) + >>> rectangle.section_modulus() + (a*b**2/6, a**2*b/6) + >>> rectangle.section_modulus(Point(a/4, b/4)) + (-a*b**2/3, -a**2*b/3) + """ + x_c, y_c = self.centroid + if point is None: + # taking x and y as maximum distances from centroid + x_min, y_min, x_max, y_max = self.bounds + y = max(y_c - y_min, y_max - y_c) + x = max(x_c - x_min, x_max - x_c) + else: + # taking x and y as distances of the given point from the centroid + y = point.y - y_c + x = point.x - x_c + + second_moment= self.second_moment_of_area() + S_x = second_moment[0]/y + S_y = second_moment[1]/x + + return S_x, S_y + + @property def sides(self): """The directed line segments that form the sides of the polygon. @@ -804,6 +964,11 @@ def cut_section(self, line): upper_polygon and lower polygon are ``None`` when no polygon exists above the line or below the line. + Raises + ====== + + ValueError: When the line does not intersect the polygon + References ========== @@ -832,7 +997,7 @@ def cut_section(self, line): if not intersection_points: raise ValueError("This line does not intersect the polygon") - points = self.vertices + points = list(self.vertices) points.append(points[0]) x, y = symbols('x, y', real=True, cls=Dummy)

diff --git a/sympy/geometry/tests/test_ellipse.py b/sympy/geometry/tests/test_ellipse.py index 1c3399136642..93b19ba629ca 100644 --- a/sympy/geometry/tests/test_ellipse.py +++ b/sympy/geometry/tests/test_ellipse.py @@ -1,4 +1,4 @@ -from sympy import Rational, S, Symbol, symbols, pi, sqrt, oo, Point2D, Segment2D, I +from sympy import Rational, S, Symbol, symbols, pi, sqrt, oo, Point2D, Segment2D, I, Abs from sympy.core.compatibility import range from sympy.geometry import (Circle, Ellipse, GeometryError, Line, Point, Polygon, Ray, RegularPolygon, Segment, Triangle, intersection) @@ -451,6 +451,28 @@ def test_second_moment_of_area(): assert I_xy == e.second_moment_of_area()[2] +def test_section_modulus_and_polar_second_moment_of_area(): + d = Symbol('d', positive=True) + c = Circle((3, 7), 8) + assert c.polar_second_moment_of_area() == 2048*pi + assert c.section_modulus() == (128*pi, 128*pi) + c = Circle((2, 9), d/2) + assert c.polar_second_moment_of_area() == pi*d**3*Abs(d)/64 + pi*d*Abs(d)**3/64 + assert c.section_modulus() == (pi*d**3/S(32), pi*d**3/S(32)) + + a, b = symbols('a, b', positive=True) + e = Ellipse((4, 6), a, b) + assert e.section_modulus() == (pi*a*b**2/S(4), pi*a**2*b/S(4)) + assert e.polar_second_moment_of_area() == pi*a**3*b/S(4) + pi*a*b**3/S(4) + e = e.rotate(pi/2) # no change in polar and section modulus + assert e.section_modulus() == (pi*a**2*b/S(4), pi*a*b**2/S(4)) + assert e.polar_second_moment_of_area() == pi*a**3*b/S(4) + pi*a*b**3/S(4) + + e = Ellipse((a, b), 2, 6) + assert e.section_modulus() == (18*pi, 6*pi) + assert e.polar_second_moment_of_area() == 120*pi + + def test_circumference(): M = Symbol('M') m = Symbol('m') diff --git a/sympy/geometry/tests/test_polygon.py b/sympy/geometry/tests/test_polygon.py index bcd6bcdc8a10..3f6c8793c982 100644 --- a/sympy/geometry/tests/test_polygon.py +++ b/sympy/geometry/tests/test_polygon.py @@ -524,6 +524,45 @@ def test_second_moment_of_area(): assert (I_xy - rectangle.second_moment_of_area(p)[2]) == 0 + r = RegularPolygon(Point(0, 0), 5, 3) + assert r.second_moment_of_area() == (1875*sqrt(3)/S(32), 1875*sqrt(3)/S(32), 0) + + +def test_first_moment(): + a, b = symbols('a, b', positive=True) + # rectangle + p1 = Polygon((0, 0), (a, 0), (a, b), (0, b)) + assert p1.first_moment_of_area() == (a*b**2/8, a**2*b/8) + assert p1.first_moment_of_area((a/3, b/4)) == (-3*a*b**2/32, -a**2*b/9) + + p1 = Polygon((0, 0), (40, 0), (40, 30), (0, 30)) + assert p1.first_moment_of_area() == (4500, 6000) + + # triangle + p2 = Polygon((0, 0), (a, 0), (a/2, b)) + assert p2.first_moment_of_area() == (4*a*b**2/81, a**2*b/24) + assert p2.first_moment_of_area((a/8, b/6)) == (-25*a*b**2/648, -5*a**2*b/768) + + p2 = Polygon((0, 0), (12, 0), (12, 30)) + p2.first_moment_of_area() == (1600/3, -640/3) + + +def test_section_modulus_and_polar_second_moment_of_area(): + a, b = symbols('a, b', positive=True) + x, y = symbols('x, y') + rectangle = Polygon((0, b), (0, 0), (a, 0), (a, b)) + assert rectangle.section_modulus(Point(x, y)) == (a*b**3/12/(-b/2 + y), a**3*b/12/(-a/2 + x)) + assert rectangle.polar_second_moment_of_area() == a**3*b/12 + a*b**3/12 + + convex = RegularPolygon((0, 0), 1, 6) + assert convex.section_modulus() == (5/S(8), 5*sqrt(3)/S(16)) + assert convex.polar_second_moment_of_area() == 5*sqrt(3)/S(8) + + concave = Polygon((0, 0), (1, 8), (3, 4), (4, 6), (7, 1)) + assert concave.section_modulus() == (-6371/S(429), -9778/S(519)) + assert concave.polar_second_moment_of_area() == -38669/S(252) + + def test_cut_section(): # concave polygon p = Polygon((-1, -1), (1, S(5)/2), (2, 1), (3, S(5)/2), (4, 2), (5, 3), (-1, 3))

[ { "components": [ { "doc": "Returns the polar second moment of area of an Ellipse\n\nIt is a constituent of the second moment of area, linked through\nthe perpendicular axis theorem. While the planar second moment of\narea describes an object's resistance to deflection (bending) when\nsubjected to...

[ "test_section_modulus_and_polar_second_moment_of_area", "test_second_moment_of_area", "test_first_moment" ]

[ "test_ellipse_equation_using_slope", "test_object_from_equation", "test_construction", "test_ellipse_random_point", "test_repr", "test_transform", "test_bounds", "test_reflect", "test_is_tangent", "test_parameter_value", "test_circumference", "test_issue_15259", "test_issue_15797_equals", ...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added functionality to determine polar second moment of area and section modulus of a polygon [Polar modulus](https://en.wikipedia.org/wiki/Polar_moment_of_inertia) and [section modulus](https://en.wikipedia.org/wiki/Section_modulus) are properties of a polygon (more specifically a cross-section). With `beam` module now accepting the cross-section (geometry object) as an alternative to the `second_moment`, this functionality would be of importance to the `beam` module, as it will be able to calculate the bending stresses and shear stresses on a beam with a particular cross-section This is in addition to previously implemented `second_moment_of_area()`. Also it takes a parameter `point` similar to that in the `second_moment_of_area()` ToDo's: - [x] Tests - [x] Documentation - [x] Implementing the same for Ellipses class - [x] method to calculate first moment of area (for polygon) #### Release Notes   - geometry - added methods in the polygon class to calculate section modulus, polar second moment of area and first moment of area of a two-dimensional polygon - added methods in the ellipse class to calculate section modulus and polar second moment of area of a two-dimensional ellipse  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/geometry/ellipse.py] (definition of Ellipse.polar_second_moment_of_area:) def polar_second_moment_of_area(self): """Returns the polar second moment of area of an Ellipse It is a constituent of the second moment of area, linked through the perpendicular axis theorem. While the planar second moment of area describes an object's resistance to deflection (bending) when subjected to a force applied to a plane parallel to the central axis, the polar second moment of area describes an object's resistance to deflection when subjected to a moment applied in a plane perpendicular to the object's central axis (i.e. parallel to the cross-section) References ========== https://en.wikipedia.org/wiki/Polar_moment_of_inertia Examples ======== >>> from sympy import symbols, Circle, Ellipse >>> c = Circle((5, 5), 4) >>> c.polar_second_moment_of_area() 128*pi >>> a, b = symbols('a, b') >>> e = Ellipse((0, 0), a, b) >>> e.polar_second_moment_of_area() pi*a**3*b/4 + pi*a*b**3/4""" (definition of Ellipse.section_modulus:) def section_modulus(self, point=None): """Returns a tuple with the section modulus of an ellipse Section modulus is a geometric property of an ellipse defined as the ratio of second moment of area to the distance of the extreme end of the ellipse from the centroidal axis. References ========== https://en.wikipedia.org/wiki/Section_modulus Parameters ========== point : Point, two-tuple of sympifyable objects, or None(default=None) point is the point at which section modulus is to be found. If "point=None" section modulus will be calculated for the point farthest from the centroidal axis of the ellipse. Returns ======= S_x, S_y: numbers or SymPy expressions S_x is the section modulus with respect to the x-axis S_y is the section modulus with respect to the y-axis A negetive sign indicates that the section modulus is determined for a point below the centroidal axis. Examples ======== >>> from sympy import Symbol, Ellipse, Circle, Point2D >>> d = Symbol('d', positive=True) >>> c = Circle((0, 0), d/2) >>> c.section_modulus() (pi*d**3/32, pi*d**3/32) >>> e = Ellipse(Point2D(0, 0), 2, 4) >>> e.section_modulus() (8*pi, 4*pi)""" [end of new definitions in sympy/geometry/ellipse.py] [start of new definitions in sympy/geometry/polygon.py] (definition of Polygon.first_moment_of_area:) def first_moment_of_area(self, point=None): """Returns the first moment of area of a two-dimensional polygon with respect to a certain point of interest. First moment of area is a measure of the distribution of the area of a polygon in relation to an axis. The first moment of area of the entire polygon about its own centroid is always zero. Therefore, here it is calculated for an area, above or below a certain point of interest, that makes up a smaller portion of the polygon. This area is bounded by the point of interest and the extreme end (top or bottom) of the polygon. The first moment for this area is is then determined about the centroidal axis of the initial polygon. References ========== https://skyciv.com/docs/tutorials/section-tutorials/calculating-the-statical-or-first-moment-of-area-of-beam-sections/?cc=BMD https://mechanicalc.com/reference/cross-sections Parameters ========== point: Point, two-tuple of sympifyable objects, or None (default=None) point is the point above or below which the area of interest lies If ``point=None`` then the centroid acts as the point of interest. Returns ======= Q_x, Q_y: number or sympy expressions Q_x is the first moment of area about the x-axis Q_y is the first moment of area about the y-axis A negetive sign indicates that the section modulus is determined for a section below (or left of) the centroidal axis Examples ======== >>> from sympy import Point, Polygon, symbol >>> a, b = 50, 10 >>> p1, p2, p3, p4 = [(0, b), (0, 0), (a, 0), (a, b)] >>> p = Polygon(p1, p2, p3, p4) >>> p.first_moment_of_area() (625, 3125) >>> p.first_moment_of_area(point=Point(30, 7)) (525, 3000)""" (definition of Polygon.polar_second_moment_of_area:) def polar_second_moment_of_area(self): """Returns the polar modulus of a two-dimensional polygon It is a constituent of the second moment of area, linked through the perpendicular axis theorem. While the planar second moment of area describes an object's resistance to deflection (bending) when subjected to a force applied to a plane parallel to the central axis, the polar second moment of area describes an object's resistance to deflection when subjected to a moment applied in a plane perpendicular to the object's central axis (i.e. parallel to the cross-section) References ========== https://en.wikipedia.org/wiki/Polar_moment_of_inertia Examples ======== >>> from sympy import Polygon, symbols >>> a, b = symbols('a, b') >>> rectangle = Polygon((0, 0), (a, 0), (a, b), (0, b)) >>> rectangle.polar_second_moment_of_area() a**3*b/12 + a*b**3/12""" (definition of Polygon.section_modulus:) def section_modulus(self, point=None): """Returns a tuple with the section modulus of a two-dimensional polygon. Section modulus is a geometric property of a polygon defined as the ratio of second moment of area to the distance of the extreme end of the polygon from the centroidal axis. References ========== https://en.wikipedia.org/wiki/Section_modulus Parameters ========== point : Point, two-tuple of sympifyable objects, or None(default=None) point is the point at which section modulus is to be found. If "point=None" it will be calculated for the point farthest from the centroidal axis of the polygon. Returns ======= S_x, S_y: numbers or SymPy expressions S_x is the section modulus with respect to the x-axis S_y is the section modulus with respect to the y-axis A negetive sign indicates that the section modulus is determined for a point below the centroidal axis Examples ======== >>> from sympy import symbols, Polygon, Point >>> a, b = symbols('a, b', positive=True) >>> rectangle = Polygon((0, 0), (a, 0), (a, b), (0, b)) >>> rectangle.section_modulus() (a*b**2/6, a**2*b/6) >>> rectangle.section_modulus(Point(a/4, b/4)) (-a*b**2/3, -a**2*b/3)""" [end of new definitions in sympy/geometry/polygon.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-17145

17,145

sympy/sympy

1.5

12d8f5354db591ba6600c50f4188b7b973a859fc

2019-07-03T13:05:19Z

diff --git a/sympy/sets/fancysets.py b/sympy/sets/fancysets.py index 0d4804359b10..413fe1ab56b3 100644 --- a/sympy/sets/fancysets.py +++ b/sympy/sets/fancysets.py @@ -9,7 +9,7 @@ from sympy.core.singleton import Singleton, S from sympy.core.symbol import Dummy, symbols from sympy.core.sympify import _sympify, sympify, converter -from sympy.logic.boolalg import And +from sympy.logic.boolalg import And, Or from sympy.sets.sets import (Set, Interval, Union, FiniteSet, ProductSet, Intersection) from sympy.sets.contains import Contains @@ -766,6 +766,15 @@ def _sup(self): def _boundary(self): return self + def as_relational(self, x): + """Rewrite a Range in terms of equalities and logic operators. """ + from sympy.functions.elementary.integers import floor + i = (x - (self.inf if self.inf.is_finite else self.sup))/self.step + return And( + Eq(i, floor(i)), + x >= self.inf if self.inf in self else x > self.inf, + x <= self.sup if self.sup in self else x < self.sup) + if PY3: converter[range] = Range

diff --git a/sympy/sets/tests/test_fancysets.py b/sympy/sets/tests/test_fancysets.py index c952fc18caac..128618cc2517 100644 --- a/sympy/sets/tests/test_fancysets.py +++ b/sympy/sets/tests/test_fancysets.py @@ -309,6 +309,10 @@ def test_Range_set(): assert Range(builtin_range(1000000000000)) == \ Range(1000000000000) + # test Range.as_relational + assert Range(1, 4).as_relational(x) == (x >= 1) & (x <= 3) & Eq(x - 1, floor(x) - 1) + assert Range(oo, 1, -2).as_relational(x) == (x >= 3) & (x < oo) & Eq((3 - x)/2, floor((3 - x)/2)) + def test_range_range_intersection(): for a, b, r in [

[ { "components": [ { "doc": "Rewrite a Range in terms of equalities and logic operators. ", "lines": [ 769, 776 ], "name": "Range.as_relational", "signature": "def as_relational(self, x):", "type": "function" } ], "file": "sy...

[ "test_Range_set" ]

[ "test_naturals", "test_naturals0", "test_integers", "test_ImageSet", "test_image_is_ImageSet", "test_halfcircle", "test_ImageSet_iterator_not_injective", "test_inf_Range_len", "test_range_range_intersection", "test_range_interval_intersection", "test_Integers_eval_imageset", "test_Range_eval_i...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> as_relational added in Range  #### References to other Issues or PRs  #### Brief description of what is fixed or changed `as_relational` method has been added to `Range`. #### Other comments ping @Upabjojr @smichr #### Release Notes   * sets * `as_relational` has been added to `Range`.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/sets/fancysets.py] (definition of Range.as_relational:) def as_relational(self, x): """Rewrite a Range in terms of equalities and logic operators. """ [end of new definitions in sympy/sets/fancysets.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-17134

17,134

sympy/sympy

1.5

de86581abcec1e9a6018f22e95010809eaf7d2f0

2019-07-01T11:26:00Z

diff --git a/sympy/series/formal.py b/sympy/series/formal.py index c6a6f1a225fa..8b7a84421217 100644 --- a/sympy/series/formal.py +++ b/sympy/series/formal.py @@ -1052,6 +1052,9 @@ def truncate(self, n=6): return self.polynomial(n) + Order(pt_xk, (x, x0)) + def zero_coeff(self): + return self._eval_term(0) + def _eval_term(self, pt): try: pt_xk = self.xk.coeff(pt) @@ -1172,13 +1175,15 @@ def product(self, other, x=None, n=6): >>> f1 = fps(sin(x)) >>> f2 = fps(exp(x)) - >>> f1.product(f2, x, 4) + >>> f1.product(f2, x).truncate(4) x + x**2 + x**3/3 + O(x**4) See Also ======== sympy.discrete.convolutions + sympy.series.formal.FormalPowerSeriesProduct + """ if x is None: @@ -1202,20 +1207,7 @@ def product(self, other, x=None, n=6): elif self.x != other.x: raise ValueError("Both series should have the same symbol.") - k = self.ak.variables[0] - coeff1 = sequence(self.ak.formula, (k, 0, oo)) - - k = other.ak.variables[0] - coeff2 = sequence(other.ak.formula, (k, 0, oo)) - - conv_coeff = convolution(coeff1[:n], coeff2[:n]) - - conv_seq = sequence(tuple(conv_coeff), (k, 0, oo)) - k = self.xk.variables[0] - xk_seq = sequence(self.xk.formula, (k, 0, oo)) - terms_seq = xk_seq * conv_seq - - return Add(*(terms_seq[:n])) + Order(self.xk.coeff(n), (self.x, self.x0)) + return FormalPowerSeriesProduct(self, other) def coeff_bell(self, n): r""" @@ -1275,16 +1267,17 @@ def compose(self, other, x=None, n=6): >>> f1 = fps(exp(x)) >>> f2 = fps(sin(x)) - >>> f1.compose(f2, x) + >>> f1.compose(f2, x).truncate() 1 + x + x**2/2 - x**4/8 - x**5/15 + O(x**6) - >>> f1.compose(f2, x, n=8) + >>> f1.compose(f2, x).truncate(8) 1 + x + x**2/2 - x**4/8 - x**5/15 - x**6/240 + x**7/90 + O(x**8) See Also ======== sympy.functions.combinatorial.numbers.bell + sympy.series.formal.FormalPowerSeriesCompose References ========== @@ -1314,19 +1307,11 @@ def compose(self, other, x=None, n=6): elif self.x != other.x: raise ValueError("Both series should have the same symbol.") - f, g = self.function, other.function if other._eval_term(0).as_coeff_mul(other.x)[0] is not S.Zero: raise ValueError("The formal power series of the inner function should not have any " "constant coefficient term.") - terms = [] - - for i in range(1, n): - bell_seq = other.coeff_bell(i) - seq = (self.bell_coeff_seq * bell_seq) - terms.append(Add(*(seq[:i])) * self.xk.coeff(i) / self.fact_seq[i-1]) - - return self._eval_term(0) + Add(*terms) + Order(self.xk.coeff(n), (self.x, self.x0)) + return FormalPowerSeriesCompose(self, other) def inverse(self, x=None, n=6): r""" @@ -1356,16 +1341,17 @@ def inverse(self, x=None, n=6): >>> f1 = fps(exp(x)) >>> f2 = fps(cos(x)) - >>> f1.inverse(x) + >>> f1.inverse(x).truncate() 1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + O(x**6) - >>> f2.inverse(x, n=8) + >>> f2.inverse(x).truncate(8) 1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + O(x**8) See Also ======== sympy.functions.combinatorial.numbers.bell + sympy.series.formal.FormalPowerSeriesInverse References ========== @@ -1379,23 +1365,11 @@ def inverse(self, x=None, n=6): if n is None: return iter(self) - f = self.function if self._eval_term(0) is S.Zero: raise ValueError("Constant coefficient should exist for an inverse of a formal" " power series to exist.") - inv = self._eval_term(0) - k = Dummy('k') - terms = [] - inv_seq = sequence(inv ** (-(k + 1)), (k, 1, oo)) - aux_seq = self.sign_seq * self.fact_seq * inv_seq - - for i in range(1, n): - bell_seq = self.coeff_bell(i) - seq = (aux_seq * bell_seq) - terms.append(Add(*(seq[:i])) * self.xk.coeff(i) / self.fact_seq[i-1]) - - return self._eval_term(0) + Add(*terms) + Order(self.xk.coeff(n), (self.x, self.x0)) + return FormalPowerSeriesInverse(self) def __add__(self, other): other = sympify(other) @@ -1464,6 +1438,280 @@ def __rmul__(self, other): return self.__mul__(other) +class FiniteFormalPowerSeries(FormalPowerSeries): + """Base Class for Product, Compose and Inverse classes""" + + def __init__(self, *args): + pass + + @property + def ffps(self): + return self.args[0] + + @property + def gfps(self): + return self.args[1] + + @property + def f(self): + return self.ffps.function + + @property + def g(self): + return self.gfps.function + + @property + def infinite(self): + raise NotImplementedError("No infinite version for an object of" + " FiniteFormalPowerSeries class.") + + def _eval_terms(self, n): + raise NotImplementedError("(%s)._eval_terms()" % self) + + def _eval_term(self, pt): + raise NotImplementedError("By the current logic, one can get terms" + "upto a certain order, instead of getting term by term.") + + def polynomial(self, n): + return self._eval_terms(n) + + def truncate(self, n=6): + ffps = self.ffps + pt_xk = ffps.xk.coeff(n) + x, x0 = ffps.x, ffps.x0 + + return self.polynomial(n) + Order(pt_xk, (x, x0)) + + def _eval_derivative(self, x): + raise NotImplementedError + + def integrate(self, x): + raise NotImplementedError + + +class FormalPowerSeriesProduct(FiniteFormalPowerSeries): + """Represents the product of two formal power series of two functions. + + No computation is performed. Terms are calculated using a term by term logic, + instead of a point by point logic. + + There are two differences between a `FormalPowerSeries` object and a + `FormalPowerSeriesProduct` object. The first argument contains the two + functions involved in the product. Also, the coefficient sequence contains + both the coefficient sequence of the formal power series of the involved functions. + + See Also + ======== + + sympy.series.formal.FormalPowerSeries + sympy.series.formal.FiniteFormalPowerSeries + + """ + + def __init__(self, *args): + ffps, gfps = self.ffps, self.gfps + + k = ffps.ak.variables[0] + self.coeff1 = sequence(ffps.ak.formula, (k, 0, oo)) + + k = gfps.ak.variables[0] + self.coeff2 = sequence(gfps.ak.formula, (k, 0, oo)) + + @property + def function(self): + """Function of the product of two formal power series.""" + return self.f * self.g + + def _eval_terms(self, n): + """ + Returns the first `n` terms of the product formal power series. + Term by term logic is implemented here. + + Examples + ======== + + >>> from sympy import fps, sin, exp, convolution + >>> from sympy.abc import x + >>> f1 = fps(sin(x)) + >>> f2 = fps(exp(x)) + >>> fprod = f1.product(f2, x) + + >>> fprod._eval_terms(4) + x**3/3 + x**2 + x + + See Also + ======== + + sympy.series.formal.FormalPowerSeries.product + + """ + coeff1, coeff2 = self.coeff1, self.coeff2 + + aks = convolution(coeff1[:n], coeff2[:n]) + + terms = [] + for i in range(0, n): + terms.append(aks[i] * self.ffps.xk.coeff(i)) + + return Add(*terms) + + +class FormalPowerSeriesCompose(FiniteFormalPowerSeries): + """Represents the composed formal power series of two functions. + + No computation is performed. Terms are calculated using a term by term logic, + instead of a point by point logic. + + There are two differences between a `FormalPowerSeries` object and a + `FormalPowerSeriesCompose` object. The first argument contains the outer + function and the inner function involved in the omposition. Also, the + coefficient sequence contains the generic sequence which is to be multiplied + by a custom `bell_seq` finite sequence. The finite terms will then be added up to + get the final terms. + + See Also + ======== + + sympy.series.formal.FormalPowerSeries + sympy.series.formal.FiniteFormalPowerSeries + + """ + + @property + def function(self): + """Function for the composed formal power series.""" + f, g, x = self.f, self.g, self.ffps.x + return f.subs(x, g) + + def _eval_terms(self, n): + """ + Returns the first `n` terms of the composed formal power series. + Term by term logic is implemented here. + + The coefficient sequence of the `FormalPowerSeriesCompose` object is the generic sequence. + It is multiplied by `bell_seq` to get a sequence, whose terms are added up to get + the final terms for the polynomial. + + Examples + ======== + + >>> from sympy import fps, sin, exp, bell + >>> from sympy.abc import x + >>> f1 = fps(exp(x)) + >>> f2 = fps(sin(x)) + >>> fcomp = f1.compose(f2, x) + + >>> fcomp._eval_terms(6) + -x**5/15 - x**4/8 + x**2/2 + x + 1 + + >>> fcomp._eval_terms(8) + x**7/90 - x**6/240 - x**5/15 - x**4/8 + x**2/2 + x + 1 + + See Also + ======== + + sympy.series.formal.FormalPowerSeries.compose + sympy.series.formal.FormalPowerSeries.coeff_bell + + """ + f, g = self.f, self.g + + ffps, gfps = self.ffps, self.gfps + terms = [ffps.zero_coeff()] + + for i in range(1, n): + bell_seq = gfps.coeff_bell(i) + seq = (ffps.bell_coeff_seq * bell_seq) + terms.append(Add(*(seq[:i])) / ffps.fact_seq[i-1] * ffps.xk.coeff(i)) + + return Add(*terms) + + +class FormalPowerSeriesInverse(FiniteFormalPowerSeries): + """Represents the Inverse of a formal power series. + + No computation is performed. Terms are calculated using a term by term logic, + instead of a point by point logic. + + There is a single difference between a `FormalPowerSeries` object and a + `FormalPowerSeriesInverse` object. The coefficient sequence contains the + generic sequence which is to be multiplied by a custom `bell_seq` finite sequence. + The finite terms will then be added up to get the final terms. + + See Also + ======== + + sympy.series.formal.FormalPowerSeries + sympy.series.formal.FiniteFormalPowerSeries + + """ + def __init__(self, *args): + ffps = self.ffps + k = ffps.xk.variables[0] + + inv = ffps.zero_coeff() + inv_seq = sequence(inv ** (-(k + 1)), (k, 1, oo)) + self.aux_seq = ffps.sign_seq * ffps.fact_seq * inv_seq + + @property + def function(self): + """Function for the inverse of a formal power series.""" + f = self.f + return 1 / f + + @property + def g(self): + raise ValueError("Only one function is considered while performing" + "inverse of a formal power series.") + + @property + def gfps(self): + raise ValueError("Only one function is considered while performing" + "inverse of a formal power series.") + + def _eval_terms(self, n): + """ + Returns the first `n` terms of the composed formal power series. + Term by term logic is implemented here. + + The coefficient sequence of the `FormalPowerSeriesInverse` object is the generic sequence. + It is multiplied by `bell_seq` to get a sequence, whose terms are added up to get + the final terms for the polynomial. + + Examples + ======== + + >>> from sympy import fps, exp, cos, bell + >>> from sympy.abc import x + >>> f1 = fps(exp(x)) + >>> f2 = fps(cos(x)) + >>> finv1, finv2 = f1.inverse(), f2.inverse() + + >>> finv1._eval_terms(6) + -x**5/120 + x**4/24 - x**3/6 + x**2/2 - x + 1 + + >>> finv2._eval_terms(8) + 61*x**6/720 + 5*x**4/24 + x**2/2 + 1 + + See Also + ======== + + sympy.series.formal.FormalPowerSeries.inverse + sympy.series.formal.FormalPowerSeries.coeff_bell + + """ + f = self.f + ffps = self.ffps + terms = [ffps.zero_coeff()] + + for i in range(1, n): + bell_seq = ffps.coeff_bell(i) + seq = (self.aux_seq * bell_seq) + terms.append(Add(*(seq[:i])) / ffps.fact_seq[i-1] * ffps.xk.coeff(i)) + + return Add(*terms) + + def fps(f, x=None, x0=0, dir=1, hyper=True, order=4, rational=True, full=False): """Generates Formal Power Series of f.

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 131bcd80a6c8..d7f688fc649f 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -3886,11 +3886,35 @@ def test_sympy__series__formal__FormalPowerSeries(): from sympy.series.formal import fps assert _test_args(fps(log(1 + x), x)) + def test_sympy__series__formal__Coeff(): from sympy.series.formal import fps assert _test_args(fps(x**2 + x + 1, x)) +@SKIP('Abstract Class') +def test_sympy__series__formal__FiniteFormalPowerSeries(): + pass + + +def test_sympy__series__formal__FormalPowerSeriesProduct(): + from sympy.series.formal import fps + f1, f2 = fps(sin(x)), fps(exp(x)) + assert _test_args(f1.product(f2, x)) + + +def test_sympy__series__formal__FormalPowerSeriesCompose(): + from sympy.series.formal import fps + f1, f2 = fps(exp(x)), fps(sin(x)) + assert _test_args(f1.compose(f2, x)) + + +def test_sympy__series__formal__FormalPowerSeriesInverse(): + from sympy.series.formal import fps + f1 = fps(exp(x)) + assert _test_args(f1.inverse(x)) + + def test_sympy__simplify__hyperexpand__Hyper_Function(): from sympy.simplify.hyperexpand import Hyper_Function assert _test_args(Hyper_Function([2], [1])) diff --git a/sympy/series/tests/test_formal.py b/sympy/series/tests/test_formal.py index 86626c1ea332..2e527352b3ab 100644 --- a/sympy/series/tests/test_formal.py +++ b/sympy/series/tests/test_formal.py @@ -3,8 +3,9 @@ airyai, acos, acosh, gamma, erf, asech, Add, Integral, Mul, integrate) from sympy.series.formal import (rational_algorithm, FormalPowerSeries, - rational_independent, simpleDE, exp_re, - hyper_re) + FormalPowerSeriesProduct, FormalPowerSeriesCompose, + FormalPowerSeriesInverse, simpleDE, + rational_independent, exp_re, hyper_re) from sympy.utilities.pytest import raises, XFAIL, slow x, y, z = symbols('x y z') @@ -508,7 +509,7 @@ def test_fps__operations(): assert fi.function == sin(x) assert fi.truncate() == x - x**3/6 + x**5/120 + O(x**6) -def test_fps__convolution(): +def test_fps__product(): f1, f2, f3 = fps(sin(x)), fps(exp(x)), fps(cos(x)) raises(ValueError, lambda: f1.product(exp(x), x)) @@ -516,11 +517,27 @@ def test_fps__convolution(): raises(ValueError, lambda: f1.product(fps(exp(x), x0=1), x, 4)) raises(ValueError, lambda: f1.product(fps(exp(y)), x, 4)) - assert f1.product(f2, x, 3) == x + x**2 + O(x**3) - assert f1.product(f2, x, 4) == x + x**2 + x**3/3 + O(x**4) - assert f1.product(f3, x, 4) == x - 2*x**3/3 + O(x**4) + fprod = f1.product(f2, x) + assert isinstance(fprod, FormalPowerSeriesProduct) + assert isinstance(fprod.ffps, FormalPowerSeries) + assert isinstance(fprod.gfps, FormalPowerSeries) + assert fprod.f == sin(x) + assert fprod.g == exp(x) + assert fprod.function == sin(x) * exp(x) + assert fprod._eval_terms(4) == x + x**2 + x**3/3 + assert fprod.truncate(4) == x + x**2 + x**3/3 + O(x**4) + assert fprod.polynomial(4) == x + x**2 + x**3/3 -def test_fps__composition(): + raises(NotImplementedError, lambda: fprod._eval_term(5)) + raises(NotImplementedError, lambda: fprod.infinite) + raises(NotImplementedError, lambda: fprod._eval_derivative(x)) + raises(NotImplementedError, lambda: fprod.integrate(x)) + + assert f1.product(f3, x)._eval_terms(4) == x - 2*x**3/3 + assert f1.product(f3, x).truncate(4) == x - 2*x**3/3 + O(x**4) + + +def test_fps__compose(): f1, f2, f3 = fps(exp(x)), fps(sin(x)), fps(cos(x)) raises(ValueError, lambda: f1.compose(sin(x), x)) @@ -531,23 +548,57 @@ def test_fps__composition(): raises(ValueError, lambda: f1.compose(f3, x)) raises(ValueError, lambda: f2.compose(f3, x)) - assert f1.compose(f2, x) == 1 + x + x**2/2 - x**4/8 - x**5/15 + O(x**6) - assert f1.compose(f2, x, n=4) == 1 + x + x**2/2 + O(x**4) - assert f1.compose(f2, x, n=8) == \ + fcomp = f1.compose(f2, x) + assert isinstance(fcomp, FormalPowerSeriesCompose) + assert isinstance(fcomp.ffps, FormalPowerSeries) + assert isinstance(fcomp.gfps, FormalPowerSeries) + assert fcomp.f == exp(x) + assert fcomp.g == sin(x) + assert fcomp.function == exp(sin(x)) + assert fcomp._eval_terms(6) == 1 + x + x**2/2 - x**4/8 - x**5/15 + assert fcomp.truncate() == 1 + x + x**2/2 - x**4/8 - x**5/15 + O(x**6) + assert fcomp.truncate(5) == 1 + x + x**2/2 - x**4/8 + O(x**5) + + raises(NotImplementedError, lambda: fcomp._eval_term(5)) + raises(NotImplementedError, lambda: fcomp.infinite) + raises(NotImplementedError, lambda: fcomp._eval_derivative(x)) + raises(NotImplementedError, lambda: fcomp.integrate(x)) + + assert f1.compose(f2, x).truncate(4) == 1 + x + x**2/2 + O(x**4) + assert f1.compose(f2, x).truncate(8) == \ 1 + x + x**2/2 - x**4/8 - x**5/15 - x**6/240 + x**7/90 + O(x**8) + assert f1.compose(f2, x).truncate(6) == \ + 1 + x + x**2/2 - x**4/8 - x**5/15 + O(x**6) + + assert f2.compose(f2, x).truncate(4) == x - x**3/3 + O(x**4) + assert f2.compose(f2, x).truncate(8) == x - x**3/3 + x**5/10 - 8*x**7/315 + O(x**8) + assert f2.compose(f2, x).truncate(6) == x - x**3/3 + x**5/10 + O(x**6) - assert f2.compose(f2, x, n=4) == x - x**3/3 + O(x**4) - assert f2.compose(f2, x, n=8) == x - x**3/3 + x**5/10 - 8*x**7/315 + O(x**8) def test_fps__inverse(): f1, f2, f3 = fps(sin(x)), fps(exp(x)), fps(cos(x)) raises(ValueError, lambda: f1.inverse(x)) - raises(ValueError, lambda: f1.inverse(x, n=8)) - assert f2.inverse(x) == 1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + O(x**6) - assert f2.inverse(x, n=8) == \ + finv = f2.inverse(x) + assert isinstance(finv, FormalPowerSeriesInverse) + assert isinstance(finv.ffps, FormalPowerSeries) + raises(ValueError, lambda: finv.gfps) + + assert finv.f == exp(x) + assert finv.function == exp(-x) + assert finv._eval_terms(5) == 1 - x + x**2/2 - x**3/6 + x**4/24 + assert finv.truncate() == 1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + O(x**6) + assert finv.truncate(5) == 1 - x + x**2/2 - x**3/6 + x**4/24 + O(x**5) + + raises(NotImplementedError, lambda: finv._eval_term(5)) + raises(ValueError, lambda: finv.g) + raises(NotImplementedError, lambda: finv.infinite) + raises(NotImplementedError, lambda: finv._eval_derivative(x)) + raises(NotImplementedError, lambda: finv.integrate(x)) + + assert f2.inverse(x).truncate(8) == \ 1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + x**6/720 - x**7/5040 + O(x**8) - assert f3.inverse(x) == 1 + x**2/2 + 5*x**4/24 + O(x**6) - assert f3.inverse(x, n=8) == 1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + O(x**8) + assert f3.inverse(x).truncate() == 1 + x**2/2 + 5*x**4/24 + O(x**6) + assert f3.inverse(x).truncate(8) == 1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + O(x**8)

[ { "components": [ { "doc": "", "lines": [ 1055, 1056 ], "name": "FormalPowerSeries.zero_coeff", "signature": "def zero_coeff(self):", "type": "function" }, { "doc": "Base Class for Product, Compose and Inverse classes"...

[ "test_rational_algorithm", "test_rational_independent", "test_simpleDE", "test_exp_re", "test_hyper_re", "test_fps", "test_fps_shift", "test_fps__Add_expr", "test_fps__asymptotic", "test_fps__fractional", "test_fps__logarithmic_singularity", "test_fps_symbolic", "test_fps__slow", "test_fps...

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [GSoC] Introduction of FormalPowerSeries sub-classes, which is being returned by product, compose and inverse functions  #### References to other Issues or PRs This PR is an extension of PR #17017 and PR #17064 #### Brief description of what is fixed or changed Added `FiniteFormalPowerSeries` class, in which the coefficient sequence is a list of real numbers, computed based on the algorithm of the function calling it. Presently, `compose` and `inverse`, which are functions of `FormalPowerSeries` class, return a `FiniteFormalPowerSeries` object. ``` >>> from sympy import * >>> x = symbols('x') >>> f1, f2 = fps(exp(x)), fps(sin(x)) >>> f1.compose(f2) FiniteFormalPowerSeries(exp(sin(x)), x, 0, 1, ([1, 1/2, 0, -1/8, -1/15], SeqFormula(x**_k, (_k, 0, oo)), 1)) >>> f1.compose(f2).truncate(6) 1 + x + x**2/2 - x**4/8 - x**5/15 + O(x**6) >>> f1.inverse() FiniteFormalPowerSeries(exp(-x), x, 0, 1, ([-1, 1/2, -1/6, 1/24, -1/120], SeqFormula(x**_k, (_k, 0, oo)), 1)) >>> f1.inverse().truncate(6) 1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + O(x**6) ``` #### Other comments **[TODO]** Once my algo PR's get merged, this PR will then require some basic minor changes. Tests and suitable documentation will be added then itself.   * series * Added `FiniteFormalPowerSeries` class in `sympy.series.formal`  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/series/formal.py] (definition of FormalPowerSeries.zero_coeff:) def zero_coeff(self): (definition of FiniteFormalPowerSeries:) class FiniteFormalPowerSeries(FormalPowerSeries): """Base Class for Product, Compose and Inverse classes""" (definition of FiniteFormalPowerSeries.__init__:) def __init__(self, *args): (definition of FiniteFormalPowerSeries.ffps:) def ffps(self): (definition of FiniteFormalPowerSeries.gfps:) def gfps(self): (definition of FiniteFormalPowerSeries.f:) def f(self): (definition of FiniteFormalPowerSeries.g:) def g(self): (definition of FiniteFormalPowerSeries.infinite:) def infinite(self): (definition of FiniteFormalPowerSeries._eval_terms:) def _eval_terms(self, n): (definition of FiniteFormalPowerSeries._eval_term:) def _eval_term(self, pt): (definition of FiniteFormalPowerSeries.polynomial:) def polynomial(self, n): (definition of FiniteFormalPowerSeries.truncate:) def truncate(self, n=6): (definition of FiniteFormalPowerSeries._eval_derivative:) def _eval_derivative(self, x): (definition of FiniteFormalPowerSeries.integrate:) def integrate(self, x): (definition of FormalPowerSeriesProduct:) class FormalPowerSeriesProduct(FiniteFormalPowerSeries): """Represents the product of two formal power series of two functions. No computation is performed. Terms are calculated using a term by term logic, instead of a point by point logic. There are two differences between a `FormalPowerSeries` object and a `FormalPowerSeriesProduct` object. The first argument contains the two functions involved in the product. Also, the coefficient sequence contains both the coefficient sequence of the formal power series of the involved functions. See Also ======== sympy.series.formal.FormalPowerSeries sympy.series.formal.FiniteFormalPowerSeries""" (definition of FormalPowerSeriesProduct.__init__:) def __init__(self, *args): (definition of FormalPowerSeriesProduct.function:) def function(self): """Function of the product of two formal power series.""" (definition of FormalPowerSeriesProduct._eval_terms:) def _eval_terms(self, n): """Returns the first `n` terms of the product formal power series. Term by term logic is implemented here. Examples ======== >>> from sympy import fps, sin, exp, convolution >>> from sympy.abc import x >>> f1 = fps(sin(x)) >>> f2 = fps(exp(x)) >>> fprod = f1.product(f2, x) >>> fprod._eval_terms(4) x**3/3 + x**2 + x See Also ======== sympy.series.formal.FormalPowerSeries.product""" (definition of FormalPowerSeriesCompose:) class FormalPowerSeriesCompose(FiniteFormalPowerSeries): """Represents the composed formal power series of two functions. No computation is performed. Terms are calculated using a term by term logic, instead of a point by point logic. There are two differences between a `FormalPowerSeries` object and a `FormalPowerSeriesCompose` object. The first argument contains the outer function and the inner function involved in the omposition. Also, the coefficient sequence contains the generic sequence which is to be multiplied by a custom `bell_seq` finite sequence. The finite terms will then be added up to get the final terms. See Also ======== sympy.series.formal.FormalPowerSeries sympy.series.formal.FiniteFormalPowerSeries""" (definition of FormalPowerSeriesCompose.function:) def function(self): """Function for the composed formal power series.""" (definition of FormalPowerSeriesCompose._eval_terms:) def _eval_terms(self, n): """Returns the first `n` terms of the composed formal power series. Term by term logic is implemented here. The coefficient sequence of the `FormalPowerSeriesCompose` object is the generic sequence. It is multiplied by `bell_seq` to get a sequence, whose terms are added up to get the final terms for the polynomial. Examples ======== >>> from sympy import fps, sin, exp, bell >>> from sympy.abc import x >>> f1 = fps(exp(x)) >>> f2 = fps(sin(x)) >>> fcomp = f1.compose(f2, x) >>> fcomp._eval_terms(6) -x**5/15 - x**4/8 + x**2/2 + x + 1 >>> fcomp._eval_terms(8) x**7/90 - x**6/240 - x**5/15 - x**4/8 + x**2/2 + x + 1 See Also ======== sympy.series.formal.FormalPowerSeries.compose sympy.series.formal.FormalPowerSeries.coeff_bell""" (definition of FormalPowerSeriesInverse:) class FormalPowerSeriesInverse(FiniteFormalPowerSeries): """Represents the Inverse of a formal power series. No computation is performed. Terms are calculated using a term by term logic, instead of a point by point logic. There is a single difference between a `FormalPowerSeries` object and a `FormalPowerSeriesInverse` object. The coefficient sequence contains the generic sequence which is to be multiplied by a custom `bell_seq` finite sequence. The finite terms will then be added up to get the final terms. See Also ======== sympy.series.formal.FormalPowerSeries sympy.series.formal.FiniteFormalPowerSeries""" (definition of FormalPowerSeriesInverse.__init__:) def __init__(self, *args): (definition of FormalPowerSeriesInverse.function:) def function(self): """Function for the inverse of a formal power series.""" (definition of FormalPowerSeriesInverse.g:) def g(self): (definition of FormalPowerSeriesInverse.gfps:) def gfps(self): (definition of FormalPowerSeriesInverse._eval_terms:) def _eval_terms(self, n): """Returns the first `n` terms of the composed formal power series. Term by term logic is implemented here. The coefficient sequence of the `FormalPowerSeriesInverse` object is the generic sequence. It is multiplied by `bell_seq` to get a sequence, whose terms are added up to get the final terms for the polynomial. Examples ======== >>> from sympy import fps, exp, cos, bell >>> from sympy.abc import x >>> f1 = fps(exp(x)) >>> f2 = fps(cos(x)) >>> finv1, finv2 = f1.inverse(), f2.inverse() >>> finv1._eval_terms(6) -x**5/120 + x**4/24 - x**3/6 + x**2/2 - x + 1 >>> finv2._eval_terms(8) 61*x**6/720 + 5*x**4/24 + x**2/2 + 1 See Also ======== sympy.series.formal.FormalPowerSeries.inverse sympy.series.formal.FormalPowerSeries.coeff_bell""" [end of new definitions in sympy/series/formal.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

scikit-learn__scikit-learn-14197

14,197

scikit-learn/scikit-learn

0.22

91819d58275adf1bb05944b9e51ff3133cebc7f9

2019-06-26T13:21:34Z

diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 2e1c639e267b7..cf3302ad62c00 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -12,6 +12,18 @@ Version 0.21.3 Changelog --------- +:mod:`sklearn.datasets` +....................... + +- |Fix| :func:`datasets.fetch_california_housing`, + :func:`datasets.fetch_covtype`, + :func:`datasets.fetch_kddcup99`, :func:`datasets.fetch_olivetti_faces`, + :func:`datasets.fetch_rcv1`, and :func:`datasets.fetch_species_distributions` + try to persist the previously cache using the new ``joblib`` if the cahced + data was persisted using the deprecated ``sklearn.externals.joblib``. This + behavior is set to be deprecated and removed in v0.23. + :pr:`14197` by `Adrin Jalali`_. + :mod:`sklearn.impute` ..................... diff --git a/sklearn/datasets/base.py b/sklearn/datasets/base.py index 0b8f73c86117b..c353746c1c326 100644 --- a/sklearn/datasets/base.py +++ b/sklearn/datasets/base.py @@ -10,6 +10,7 @@ import csv import sys import shutil +import warnings from collections import namedtuple from os import environ, listdir, makedirs from os.path import dirname, exists, expanduser, isdir, join, splitext @@ -919,3 +920,31 @@ def _fetch_remote(remote, dirname=None): "file may be corrupted.".format(file_path, checksum, remote.checksum)) return file_path + + +def _refresh_cache(files, compress): + # TODO: REMOVE in v0.23 + import joblib + msg = "sklearn.externals.joblib is deprecated in 0.21" + with warnings.catch_warnings(record=True) as warns: + data = tuple([joblib.load(f) for f in files]) + + refresh_needed = any([str(x.message).startswith(msg) for x in warns]) + + other_warns = [w for w in warns if not str(w.message).startswith(msg)] + for w in other_warns: + warnings.warn(message=w.message, category=w.category) + + if refresh_needed: + try: + for value, path in zip(data, files): + joblib.dump(value, path, compress=compress) + except IOError: + message = ("This dataset will stop being loadable in scikit-learn " + "version 0.23 because it references a deprecated " + "import path. Consider removing the following files " + "and allowing it to be cached anew:\n%s" + % ("\n".join(files))) + warnings.warn(message=message, category=DeprecationWarning) + + return data[0] if len(data) == 1 else data diff --git a/sklearn/datasets/california_housing.py b/sklearn/datasets/california_housing.py index 35f0847c1de05..7d8b1aa3ede45 100644 --- a/sklearn/datasets/california_housing.py +++ b/sklearn/datasets/california_housing.py @@ -34,6 +34,7 @@ from .base import _fetch_remote from .base import _pkl_filepath from .base import RemoteFileMetadata +from .base import _refresh_cache from ..utils import Bunch # The original data can be found at: @@ -129,7 +130,9 @@ def fetch_california_housing(data_home=None, download_if_missing=True, remove(archive_path) else: - cal_housing = joblib.load(filepath) + cal_housing = _refresh_cache([filepath], 6) + # TODO: Revert to the following line in v0.23 + # cal_housing = joblib.load(filepath) feature_names = ["MedInc", "HouseAge", "AveRooms", "AveBedrms", "Population", "AveOccup", "Latitude", "Longitude"] diff --git a/sklearn/datasets/covtype.py b/sklearn/datasets/covtype.py index 9d995810bee3f..4108b1d79f84b 100644 --- a/sklearn/datasets/covtype.py +++ b/sklearn/datasets/covtype.py @@ -25,6 +25,7 @@ from .base import get_data_home from .base import _fetch_remote from .base import RemoteFileMetadata +from .base import _refresh_cache from ..utils import Bunch from .base import _pkl_filepath from ..utils import check_random_state @@ -125,8 +126,10 @@ def fetch_covtype(data_home=None, download_if_missing=True, try: X, y except NameError: - X = joblib.load(samples_path) - y = joblib.load(targets_path) + X, y = _refresh_cache([samples_path, targets_path], 9) + # TODO: Revert to the following two lines in v0.23 + # X = joblib.load(samples_path) + # y = joblib.load(targets_path) if shuffle: ind = np.arange(X.shape[0]) diff --git a/sklearn/datasets/kddcup99.py b/sklearn/datasets/kddcup99.py index 837a489e7212c..f50f49f85ab6f 100644 --- a/sklearn/datasets/kddcup99.py +++ b/sklearn/datasets/kddcup99.py @@ -20,6 +20,7 @@ from .base import _fetch_remote from .base import get_data_home from .base import RemoteFileMetadata +from .base import _refresh_cache from ..utils import Bunch from ..utils import check_random_state from ..utils import shuffle as shuffle_method @@ -292,8 +293,10 @@ def _fetch_brute_kddcup99(data_home=None, try: X, y except NameError: - X = joblib.load(samples_path) - y = joblib.load(targets_path) + X, y = _refresh_cache([samples_path, targets_path], 0) + # TODO: Revert to the following two lines in v0.23 + # X = joblib.load(samples_path) + # y = joblib.load(targets_path) return Bunch(data=X, target=y) diff --git a/sklearn/datasets/olivetti_faces.py b/sklearn/datasets/olivetti_faces.py index a52f90414e104..24eeb7927abcf 100644 --- a/sklearn/datasets/olivetti_faces.py +++ b/sklearn/datasets/olivetti_faces.py @@ -24,6 +24,7 @@ from .base import _fetch_remote from .base import RemoteFileMetadata from .base import _pkl_filepath +from .base import _refresh_cache from ..utils import check_random_state, Bunch # The original data can be found at: @@ -107,7 +108,9 @@ def fetch_olivetti_faces(data_home=None, shuffle=False, random_state=0, joblib.dump(faces, filepath, compress=6) del mfile else: - faces = joblib.load(filepath) + faces = _refresh_cache([filepath], 6) + # TODO: Revert to the following line in v0.23 + # faces = joblib.load(filepath) # We want floating point data, but float32 is enough (there is only # one byte of precision in the original uint8s anyway) diff --git a/sklearn/datasets/rcv1.py b/sklearn/datasets/rcv1.py index c95cf1d1be75a..c000acf13e249 100644 --- a/sklearn/datasets/rcv1.py +++ b/sklearn/datasets/rcv1.py @@ -22,6 +22,7 @@ from .base import _pkl_filepath from .base import _fetch_remote from .base import RemoteFileMetadata +from .base import _refresh_cache from .svmlight_format import load_svmlight_files from ..utils import shuffle as shuffle_ from ..utils import Bunch @@ -189,8 +190,10 @@ def fetch_rcv1(data_home=None, subset='all', download_if_missing=True, f.close() remove(f.name) else: - X = joblib.load(samples_path) - sample_id = joblib.load(sample_id_path) + X, sample_id = _refresh_cache([samples_path, sample_id_path], 9) + # TODO: Revert to the following two lines in v0.23 + # X = joblib.load(samples_path) + # sample_id = joblib.load(sample_id_path) # load target (y), categories, and sample_id_bis if download_if_missing and (not exists(sample_topics_path) or @@ -243,8 +246,10 @@ def fetch_rcv1(data_home=None, subset='all', download_if_missing=True, joblib.dump(y, sample_topics_path, compress=9) joblib.dump(categories, topics_path, compress=9) else: - y = joblib.load(sample_topics_path) - categories = joblib.load(topics_path) + y, categories = _refresh_cache([sample_topics_path, topics_path], 9) + # TODO: Revert to the following two lines in v0.23 + # y = joblib.load(sample_topics_path) + # categories = joblib.load(topics_path) if subset == 'all': pass diff --git a/sklearn/datasets/species_distributions.py b/sklearn/datasets/species_distributions.py index f9a04f92b8486..82ae22129ab9b 100644 --- a/sklearn/datasets/species_distributions.py +++ b/sklearn/datasets/species_distributions.py @@ -51,6 +51,7 @@ from .base import RemoteFileMetadata from ..utils import Bunch from .base import _pkl_filepath +from .base import _refresh_cache # The original data can be found at: # https://biodiversityinformatics.amnh.org/open_source/maxent/samples.zip @@ -259,6 +260,8 @@ def fetch_species_distributions(data_home=None, **extra_params) joblib.dump(bunch, archive_path, compress=9) else: - bunch = joblib.load(archive_path) + bunch = _refresh_cache([archive_path], 9) + # TODO: Revert to the following line in v0.23 + # bunch = joblib.load(archive_path) return bunch

diff --git a/sklearn/datasets/tests/test_base.py b/sklearn/datasets/tests/test_base.py index 1b58115d337e7..5e0af0318729f 100644 --- a/sklearn/datasets/tests/test_base.py +++ b/sklearn/datasets/tests/test_base.py @@ -8,6 +8,7 @@ from functools import partial import pytest +import joblib import numpy as np from sklearn.datasets import get_data_home @@ -23,6 +24,7 @@ from sklearn.datasets import load_boston from sklearn.datasets import load_wine from sklearn.datasets.base import Bunch +from sklearn.datasets.base import _refresh_cache from sklearn.datasets.tests.test_common import check_return_X_y from sklearn.externals._pilutil import pillow_installed @@ -276,3 +278,55 @@ def test_bunch_dir(): # check that dir (important for autocomplete) shows attributes data = load_iris() assert "data" in dir(data) + + +def test_refresh_cache(monkeypatch): + # uses pytests monkeypatch fixture + # https://docs.pytest.org/en/latest/monkeypatch.html + + def _load_warn(*args, **kwargs): + # raise the warning from "externals.joblib.__init__.py" + # this is raised when a file persisted by the old joblib is loaded now + msg = ("sklearn.externals.joblib is deprecated in 0.21 and will be " + "removed in 0.23. Please import this functionality directly " + "from joblib, which can be installed with: pip install joblib. " + "If this warning is raised when loading pickled models, you " + "may need to re-serialize those models with scikit-learn " + "0.21+.") + warnings.warn(msg, DeprecationWarning) + return 0 + + def _load_warn_unrelated(*args, **kwargs): + warnings.warn("unrelated warning", DeprecationWarning) + return 0 + + def _dump_safe(*args, **kwargs): + pass + + def _dump_raise(*args, **kwargs): + # this happens if the file is read-only and joblib.dump fails to write + # on it. + raise IOError() + + # test if the dataset spesific warning is raised if load raises the joblib + # warning, and dump fails to dump with new joblib + monkeypatch.setattr(joblib, "load", _load_warn) + monkeypatch.setattr(joblib, "dump", _dump_raise) + msg = "This dataset will stop being loadable in scikit-learn" + with pytest.warns(DeprecationWarning, match=msg): + _refresh_cache('test', 0) + + # make sure no warning is raised if load raises the warning, but dump + # manages to dump the new data + monkeypatch.setattr(joblib, "load", _load_warn) + monkeypatch.setattr(joblib, "dump", _dump_safe) + with pytest.warns(None) as warns: + _refresh_cache('test', 0) + assert len(warns) == 0 + + # test if an unrelated warning is still passed through and not suppressed + # by _refresh_cache + monkeypatch.setattr(joblib, "load", _load_warn_unrelated) + monkeypatch.setattr(joblib, "dump", _dump_safe) + with pytest.warns(DeprecationWarning, match="unrelated warning"): + _refresh_cache('test', 0)

diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 2e1c639e267b7..cf3302ad62c00 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -12,6 +12,18 @@ Version 0.21.3 Changelog --------- +:mod:`sklearn.datasets` +....................... + +- |Fix| :func:`datasets.fetch_california_housing`, + :func:`datasets.fetch_covtype`, + :func:`datasets.fetch_kddcup99`, :func:`datasets.fetch_olivetti_faces`, + :func:`datasets.fetch_rcv1`, and :func:`datasets.fetch_species_distributions` + try to persist the previously cache using the new ``joblib`` if the cahced + data was persisted using the deprecated ``sklearn.externals.joblib``. This + behavior is set to be deprecated and removed in v0.23. + :pr:`14197` by `Adrin Jalali`_. + :mod:`sklearn.impute` .....................

[ { "components": [ { "doc": "", "lines": [ 925, 950 ], "name": "_refresh_cache", "signature": "def _refresh_cache(files, compress):", "type": "function" } ], "file": "sklearn/datasets/base.py" } ]

[ "sklearn/datasets/tests/test_base.py::test_data_home", "sklearn/datasets/tests/test_base.py::test_default_empty_load_files", "sklearn/datasets/tests/test_base.py::test_default_load_files", "sklearn/datasets/tests/test_base.py::test_load_files_w_categories_desc_and_encoding", "sklearn/datasets/tests/test_bas...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> FIX introduce a refresh_cache param to `fetch_...` functions. This kinda fixes #14177. This does not change the warning message. But it introduces a `refresh_cache` parameter to the `fetch_...` functions that download and persist the data using `joblib`. The proposal is to add this parameter, with some variation after reviews: ``` + refresh_cache : str or bool, optional (default='joblib') + - ``True``: remove the previously downloaded data, and fetche it again. + - ``'joblib'``: only re-fetch the data if the previously downloaded + data has been persisted using the previously vendored `joblib`. + - ``False``: do not re-fetch the data. + + From version 0.23, ``'joblib'`` as an input value will be ignored and + assumed ``False``. + + .. versionadded:: 0.21.3 ``` I've changed only one of the dataset files, will fix the others once we agree on a solution. @glemaitre @jnothman ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/datasets/base.py] (definition of _refresh_cache:) def _refresh_cache(files, compress): [end of new definitions in sklearn/datasets/base.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Better warning message with deprecation of sklearn.externals._joblib When loading the olivetti dataset, I got the deprecation warning: ```python "sklearn.externals.joblib is deprecated in 0.21 and will be removed " "in 0.23. Please import this functionality directly from joblib, " "which can be installed with: pip install joblib. If this warning is " "raised when loading pickled models, you may need to re-serialize " "those models with scikit-learn 0.21+." ``` It is due that the dataset was downloaded and pickled with an old scikit-learn. I have 2 suggestions: 1. "you may need to re-serialize those models with scikit-learn 0.21+" does not seem enough. We should mention that the models should be serialized with sklearn 0.21+ and joblib directly (externals.joblib is still existing). 2. It might be interesting to detect the case of the dataset. It does not have anything to do with the models and the user might wonder what is going on. If we detect the warning after calling `fetch_***` we could first remove the pickle and re-pickle using joblib which will avoid raising the deprecation warning after. ---------- Another point which we could improve is to tell the user where those data are located. I don't think most people know where to go and delete the files. We are just mentioned the following: ``` Specify another download and cache folder for the datasets. By default all scikit-learn data is stored in ‘~/scikit_learn_data’ subfolders. ``` I might not make it easy for Windows users to know what mean `~/`. Yes, but that's hidden in the docstring of the parameter, and most users would just call the function with the default value, then get the warning message, and not know how to follow up with it. Oh I see. Yes you are right. I would be okay to detect this case and re-cache over a deprecation period... (but we have to also allow for the cache not being writable, I think.) It could even go into 0.21.3 > I would be okay to detect this case and re-cache over a deprecation period... (but we have to also allow for the cache not being writable, I think.) You mean to automatically re-cache now, until a certain version? or the other way around? I think re-cache now until a certain version?? Sounds good to me, I'll get on it :) Thanks @adrinjalali -------------------- </issues>

c96e0958da46ebef482a4084cdda3285d5f5ad23

scikit-learn__scikit-learn-14180

14,180

scikit-learn/scikit-learn

0.23

b9403f62ac65e7e6575168ef74b43fb012010599

2019-06-25T02:18:38Z

diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 3d9924638b69b..2489eaf55bac7 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -1569,6 +1569,7 @@ Plotting utils.deprecated utils.estimator_checks.check_estimator utils.estimator_checks.parametrize_with_checks + utils.estimator_html_repr utils.extmath.safe_sparse_dot utils.extmath.randomized_range_finder utils.extmath.randomized_svd diff --git a/doc/modules/compose.rst b/doc/modules/compose.rst index cd29b14b1f081..e7dac0dadc630 100644 --- a/doc/modules/compose.rst +++ b/doc/modules/compose.rst @@ -528,6 +528,31 @@ above example would be:: ('countvectorizer', CountVectorizer(), 'title')]) +.. _visualizing_composite_estimators: + +Visualizing Composite Estimators +================================ + +Estimators can be displayed with a HTML representation when shown in a +jupyter notebook. This can be useful to diagnose or visualize a Pipeline with +many estimators. This visualization is activated by setting the +`display` option in :func:`sklearn.set_config`:: + + >>> from sklearn import set_config + >>> set_config(display='diagram') # doctest: +SKIP + >>> # diplays HTML representation in a jupyter context + >>> column_trans # doctest: +SKIP + +An example of the HTML output can be seen in the +**HTML representation of Pipeline** section of +:ref:`sphx_glr_auto_examples_compose_plot_column_transformer_mixed_types.py`. +As an alternative, the HTML can be written to a file using +:func:`~sklearn.utils.estimator_html_repr`:: + + >>> from sklearn.utils import estimator_html_repr + >>> with open('my_estimator.html', 'w') as f: # doctest: +SKIP + ... f.write(estimator_html_repr(clf)) + .. topic:: Examples: * :ref:`sphx_glr_auto_examples_compose_plot_column_transformer.py` diff --git a/doc/whats_new/v0.23.rst b/doc/whats_new/v0.23.rst index 0e149ed03a9fa..1ac63ca473faf 100644 --- a/doc/whats_new/v0.23.rst +++ b/doc/whats_new/v0.23.rst @@ -567,6 +567,9 @@ Changelog :mod:`sklearn.utils` .................... +- |Feature| Adds :func:`utils.estimator_html_repr` for returning a + HTML representation of an estimator. :pr:`14180` by `Thomas Fan`_. + - |Enhancement| improve error message in :func:`utils.validation.column_or_1d`. :pr:`15926` by :user:`Loïc Estève <lesteve>`. @@ -605,6 +608,11 @@ Changelog Miscellaneous ............. +- |MajorFeature| Adds a HTML representation of estimators to be shown in + a jupyter notebook or lab. This visualization is acitivated by setting the + `display` option in :func:`sklearn.set_config`. :pr:`14180` by + `Thomas Fan`_. + - |Enhancement| ``scikit-learn`` now works with ``mypy`` without errors. :pr:`16726` by `Roman Yurchak`_. diff --git a/examples/compose/plot_column_transformer_mixed_types.py b/examples/compose/plot_column_transformer_mixed_types.py index 1c79c4bb1d607..24fc4d69e35d0 100644 --- a/examples/compose/plot_column_transformer_mixed_types.py +++ b/examples/compose/plot_column_transformer_mixed_types.py @@ -87,6 +87,15 @@ clf.fit(X_train, y_train) print("model score: %.3f" % clf.score(X_test, y_test)) +############################################################################## +# HTML representation of ``Pipeline`` +############################################################################### +# When the ``Pipeline`` is printed out in a jupyter notebook an HTML +# representation of the estimator is displayed as follows: +from sklearn import set_config +set_config(display='diagram') +clf + ############################################################################### # Use ``ColumnTransformer`` by selecting column by data types ############################################################################### diff --git a/sklearn/_config.py b/sklearn/_config.py index 44eaae1d59012..f183203e13228 100644 --- a/sklearn/_config.py +++ b/sklearn/_config.py @@ -7,6 +7,7 @@ 'assume_finite': bool(os.environ.get('SKLEARN_ASSUME_FINITE', False)), 'working_memory': int(os.environ.get('SKLEARN_WORKING_MEMORY', 1024)), 'print_changed_only': True, + 'display': 'text', } @@ -27,7 +28,7 @@ def get_config(): def set_config(assume_finite=None, working_memory=None, - print_changed_only=None): + print_changed_only=None, display=None): """Set global scikit-learn configuration .. versionadded:: 0.19 @@ -59,6 +60,13 @@ def set_config(assume_finite=None, working_memory=None, .. versionadded:: 0.21 + display : {'text', 'diagram'}, optional + If 'diagram', estimators will be displayed as text in a jupyter lab + of notebook context. If 'text', estimators will be displayed as + text. Default is 'text'. + + .. versionadded:: 0.23 + See Also -------- config_context: Context manager for global scikit-learn configuration @@ -70,6 +78,8 @@ def set_config(assume_finite=None, working_memory=None, _global_config['working_memory'] = working_memory if print_changed_only is not None: _global_config['print_changed_only'] = print_changed_only + if display is not None: + _global_config['display'] = display @contextmanager @@ -100,6 +110,13 @@ def config_context(**new_config): .. versionchanged:: 0.23 Default changed from False to True. + display : {'text', 'diagram'}, optional + If 'diagram', estimators will be displayed as text in a jupyter lab + of notebook context. If 'text', estimators will be displayed as + text. Default is 'text'. + + .. versionadded:: 0.23 + Notes ----- All settings, not just those presently modified, will be returned to diff --git a/sklearn/base.py b/sklearn/base.py index bf5ee370aa8f1..666574b491594 100644 --- a/sklearn/base.py +++ b/sklearn/base.py @@ -17,9 +17,11 @@ import numpy as np from . import __version__ +from ._config import get_config from .utils import _IS_32BIT from .utils.validation import check_X_y from .utils.validation import check_array +from .utils._estimator_html_repr import estimator_html_repr from .utils.validation import _deprecate_positional_args _DEFAULT_TAGS = { @@ -435,6 +437,17 @@ def _validate_data(self, X, y=None, reset=True, return out + def _repr_html_(self): + """HTML representation of estimator""" + return estimator_html_repr(self) + + def _repr_mimebundle_(self, **kwargs): + """Mime bundle used by jupyter kernels to display estimator""" + output = {"text/plain": repr(self)} + if get_config()["display"] == 'diagram': + output["text/html"] = estimator_html_repr(self) + return output + class ClassifierMixin: """Mixin class for all classifiers in scikit-learn.""" diff --git a/sklearn/compose/_column_transformer.py b/sklearn/compose/_column_transformer.py index 2ef8876b0c4e7..f148633021a97 100644 --- a/sklearn/compose/_column_transformer.py +++ b/sklearn/compose/_column_transformer.py @@ -15,6 +15,7 @@ from joblib import Parallel, delayed from ..base import clone, TransformerMixin +from ..utils._estimator_html_repr import _VisualBlock from ..pipeline import _fit_transform_one, _transform_one, _name_estimators from ..preprocessing import FunctionTransformer from ..utils import Bunch @@ -637,6 +638,11 @@ def _hstack(self, Xs): Xs = [f.toarray() if sparse.issparse(f) else f for f in Xs] return np.hstack(Xs) + def _sk_visual_block_(self): + names, transformers, name_details = zip(*self.transformers) + return _VisualBlock('parallel', transformers, + names=names, name_details=name_details) + def _check_X(X): """Use check_array only on lists and other non-array-likes / sparse""" diff --git a/sklearn/ensemble/_stacking.py b/sklearn/ensemble/_stacking.py index a75e9236f1612..73aa55c0575a7 100644 --- a/sklearn/ensemble/_stacking.py +++ b/sklearn/ensemble/_stacking.py @@ -13,6 +13,7 @@ from ..base import clone from ..base import ClassifierMixin, RegressorMixin, TransformerMixin from ..base import is_classifier, is_regressor +from ..utils._estimator_html_repr import _VisualBlock from ._base import _fit_single_estimator from ._base import _BaseHeterogeneousEnsemble @@ -233,6 +234,14 @@ def predict(self, X, **predict_params): self.transform(X), **predict_params ) + def _sk_visual_block_(self, final_estimator): + names, estimators = zip(*self.estimators) + parallel = _VisualBlock('parallel', estimators, names=names, + dash_wrapped=False) + serial = _VisualBlock('serial', (parallel, final_estimator), + dash_wrapped=False) + return _VisualBlock('serial', [serial]) + class StackingClassifier(ClassifierMixin, _BaseStacking): """Stack of estimators with a final classifier. @@ -496,6 +505,15 @@ def transform(self, X): """ return self._transform(X) + def _sk_visual_block_(self): + # If final_estimator's default changes then this should be + # updated. + if self.final_estimator is None: + final_estimator = LogisticRegression() + else: + final_estimator = self.final_estimator + return super()._sk_visual_block_(final_estimator) + class StackingRegressor(RegressorMixin, _BaseStacking): """Stack of estimators with a final regressor. @@ -665,3 +683,12 @@ def transform(self, X): Prediction outputs for each estimator. """ return self._transform(X) + + def _sk_visual_block_(self): + # If final_estimator's default changes then this should be + # updated. + if self.final_estimator is None: + final_estimator = RidgeCV() + else: + final_estimator = self.final_estimator + return super()._sk_visual_block_(final_estimator) diff --git a/sklearn/ensemble/_voting.py b/sklearn/ensemble/_voting.py index 0ac42407f5998..6a2b5736d8b4e 100644 --- a/sklearn/ensemble/_voting.py +++ b/sklearn/ensemble/_voting.py @@ -32,6 +32,7 @@ from ..utils.validation import column_or_1d from ..utils.validation import _deprecate_positional_args from ..exceptions import NotFittedError +from ..utils._estimator_html_repr import _VisualBlock class _BaseVoting(TransformerMixin, _BaseHeterogeneousEnsemble): @@ -104,6 +105,10 @@ def n_features_in_(self): return self.estimators_[0].n_features_in_ + def _sk_visual_block_(self): + names, estimators = zip(*self.estimators) + return _VisualBlock('parallel', estimators, names=names) + class VotingClassifier(ClassifierMixin, _BaseVoting): """Soft Voting/Majority Rule classifier for unfitted estimators. diff --git a/sklearn/pipeline.py b/sklearn/pipeline.py index 8e2a539786557..6f02cb565e15c 100644 --- a/sklearn/pipeline.py +++ b/sklearn/pipeline.py @@ -18,6 +18,7 @@ from joblib import Parallel, delayed from .base import clone, TransformerMixin +from .utils._estimator_html_repr import _VisualBlock from .utils.metaestimators import if_delegate_has_method from .utils import Bunch, _print_elapsed_time from .utils.validation import check_memory @@ -623,6 +624,21 @@ def n_features_in_(self): # delegate to first step (which will call _check_is_fitted) return self.steps[0][1].n_features_in_ + def _sk_visual_block_(self): + _, estimators = zip(*self.steps) + + def _get_name(name, est): + if est is None or est == 'passthrough': + return f'{name}: passthrough' + # Is an estimator + return f'{name}: {est.__class__.__name__}' + names = [_get_name(name, est) for name, est in self.steps] + name_details = [str(est) for est in estimators] + return _VisualBlock('serial', estimators, + names=names, + name_details=name_details, + dash_wrapped=False) + def _name_estimators(estimators): """Generate names for estimators.""" @@ -1004,6 +1020,10 @@ def n_features_in_(self): # X is passed to all transformers so we just delegate to the first one return self.transformer_list[0][1].n_features_in_ + def _sk_visual_block_(self): + names, transformers = zip(*self.transformer_list) + return _VisualBlock('parallel', transformers, names=names) + def make_union(*transformers, **kwargs): """ diff --git a/sklearn/utils/__init__.py b/sklearn/utils/__init__.py index afde7614070fd..f814ea11c12c1 100644 --- a/sklearn/utils/__init__.py +++ b/sklearn/utils/__init__.py @@ -25,6 +25,7 @@ from ..exceptions import DataConversionWarning from .deprecation import deprecated from .fixes import np_version +from ._estimator_html_repr import estimator_html_repr from .validation import (as_float_array, assert_all_finite, check_random_state, column_or_1d, check_array, @@ -52,7 +53,7 @@ "check_symmetric", "indices_to_mask", "deprecated", "parallel_backend", "register_parallel_backend", "resample", "shuffle", "check_matplotlib_support", "all_estimators", - "DataConversionWarning" + "DataConversionWarning", "estimator_html_repr" ] IS_PYPY = platform.python_implementation() == 'PyPy' diff --git a/sklearn/utils/_estimator_html_repr.py b/sklearn/utils/_estimator_html_repr.py new file mode 100644 index 0000000000000..9b2e45790fd2b --- /dev/null +++ b/sklearn/utils/_estimator_html_repr.py @@ -0,0 +1,311 @@ +from contextlib import closing +from contextlib import suppress +from io import StringIO +import uuid +import html + +from sklearn import config_context + + +class _VisualBlock: + """HTML Representation of Estimator + + Parameters + ---------- + kind : {'serial', 'parallel', 'single'} + kind of HTML block + + estimators : list of estimators or `_VisualBlock`s or a single estimator + If kind != 'single', then `estimators` is a list of + estimators. + If kind == 'single', then `estimators` is a single estimator. + + names : list of str + If kind != 'single', then `names` corresponds to estimators. + If kind == 'single', then `names` is a single string corresponding to + the single estimator. + + name_details : list of str, str, or None, default=None + If kind != 'single', then `name_details` corresponds to `names`. + If kind == 'single', then `name_details` is a single string + corresponding to the single estimator. + + dash_wrapped : bool, default=True + If true, wrapped HTML element will be wrapped with a dashed border. + Only active when kind != 'single'. + """ + def __init__(self, kind, estimators, *, names=None, name_details=None, + dash_wrapped=True): + self.kind = kind + self.estimators = estimators + self.dash_wrapped = dash_wrapped + + if self.kind in ('parallel', 'serial'): + if names is None: + names = (None, ) * len(estimators) + if name_details is None: + name_details = (None, ) * len(estimators) + + self.names = names + self.name_details = name_details + + def _sk_visual_block_(self): + return self + + +def _write_label_html(out, name, name_details, + outer_class="sk-label-container", + inner_class="sk-label", + checked=False): + """Write labeled html with or without a dropdown with named details""" + out.write(f'<div class="{outer_class}">' + f'<div class="{inner_class} sk-toggleable">') + name = html.escape(name) + + if name_details is not None: + checked_str = 'checked' if checked else '' + est_id = uuid.uuid4() + out.write(f'<input class="sk-toggleable__control sk-hidden--visually" ' + f'id="{est_id}" type="checkbox" {checked_str}>' + f'<label class="sk-toggleable__label" for="{est_id}">' + f'{name}</label>' + f'<div class="sk-toggleable__content"><pre>{name_details}' + f'</pre></div>') + else: + out.write(f'<label>{name}</label>') + out.write('</div></div>') # outer_class inner_class + + +def _get_visual_block(estimator): + """Generate information about how to display an estimator. + """ + with suppress(AttributeError): + return estimator._sk_visual_block_() + + if isinstance(estimator, str): + return _VisualBlock('single', estimator, + names=estimator, name_details=estimator) + elif estimator is None: + return _VisualBlock('single', estimator, + names='None', name_details='None') + + # check if estimator looks like a meta estimator wraps estimators + if hasattr(estimator, 'get_params'): + estimators = [] + for key, value in estimator.get_params().items(): + # Only look at the estimators in the first layer + if '__' not in key and hasattr(value, 'get_params'): + estimators.append(value) + if len(estimators): + return _VisualBlock('parallel', estimators, names=None) + + return _VisualBlock('single', estimator, + names=estimator.__class__.__name__, + name_details=str(estimator)) + + +def _write_estimator_html(out, estimator, estimator_label, + estimator_label_details, first_call=False): + """Write estimator to html in serial, parallel, or by itself (single). + """ + if first_call: + est_block = _get_visual_block(estimator) + else: + with config_context(print_changed_only=True): + est_block = _get_visual_block(estimator) + + if est_block.kind in ('serial', 'parallel'): + dashed_wrapped = first_call or est_block.dash_wrapped + dash_cls = " sk-dashed-wrapped" if dashed_wrapped else "" + out.write(f'<div class="sk-item{dash_cls}">') + + if estimator_label: + _write_label_html(out, estimator_label, estimator_label_details) + + kind = est_block.kind + out.write(f'<div class="sk-{kind}">') + est_infos = zip(est_block.estimators, est_block.names, + est_block.name_details) + + for est, name, name_details in est_infos: + if kind == 'serial': + _write_estimator_html(out, est, name, name_details) + else: # parallel + out.write('<div class="sk-parallel-item">') + # wrap element in a serial visualblock + serial_block = _VisualBlock('serial', [est], + dash_wrapped=False) + _write_estimator_html(out, serial_block, name, name_details) + out.write('</div>') # sk-parallel-item + + out.write('</div></div>') + elif est_block.kind == 'single': + _write_label_html(out, est_block.names, est_block.name_details, + outer_class="sk-item", inner_class="sk-estimator", + checked=first_call) + + +_STYLE = """ +div.sk-top-container { + color: black; + background-color: white; +} +div.sk-toggleable { + background-color: white; +} +label.sk-toggleable__label { + cursor: pointer; + display: block; + width: 100%; + margin-bottom: 0; + padding: 0.2em 0.3em; + box-sizing: border-box; + text-align: center; +} +div.sk-toggleable__content { + max-height: 0; + max-width: 0; + overflow: hidden; + text-align: left; + background-color: #f0f8ff; +} +div.sk-toggleable__content pre { + margin: 0.2em; + color: black; + border-radius: 0.25em; + background-color: #f0f8ff; +} +input.sk-toggleable__control:checked~div.sk-toggleable__content { + max-height: 200px; + max-width: 100%; + overflow: auto; +} +div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label { + background-color: #d4ebff; +} +div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label { + background-color: #d4ebff; +} +input.sk-hidden--visually { + border: 0; + clip: rect(1px 1px 1px 1px); + clip: rect(1px, 1px, 1px, 1px); + height: 1px; + margin: -1px; + overflow: hidden; + padding: 0; + position: absolute; + width: 1px; +} +div.sk-estimator { + font-family: monospace; + background-color: #f0f8ff; + margin: 0.25em 0.25em; + border: 1px dotted black; + border-radius: 0.25em; + box-sizing: border-box; +} +div.sk-estimator:hover { + background-color: #d4ebff; +} +div.sk-parallel-item::after { + content: ""; + width: 100%; + border-bottom: 1px solid gray; + flex-grow: 1; +} +div.sk-label:hover label.sk-toggleable__label { + background-color: #d4ebff; +} +div.sk-serial::before { + content: ""; + position: absolute; + border-left: 1px solid gray; + box-sizing: border-box; + top: 2em; + bottom: 0; + left: 50%; +} +div.sk-serial { + display: flex; + flex-direction: column; + align-items: center; + background-color: white; +} +div.sk-item { + z-index: 1; +} +div.sk-parallel { + display: flex; + align-items: stretch; + justify-content: center; + background-color: white; +} +div.sk-parallel-item { + display: flex; + flex-direction: column; + position: relative; + background-color: white; +} +div.sk-parallel-item:first-child::after { + align-self: flex-end; + width: 50%; +} +div.sk-parallel-item:last-child::after { + align-self: flex-start; + width: 50%; +} +div.sk-parallel-item:only-child::after { + width: 0; +} +div.sk-dashed-wrapped { + border: 1px dashed gray; + margin: 0.2em; + box-sizing: border-box; + padding-bottom: 0.1em; + background-color: white; + position: relative; +} +div.sk-label label { + font-family: monospace; + font-weight: bold; + background-color: white; + display: inline-block; + line-height: 1.2em; +} +div.sk-label-container { + position: relative; + z-index: 2; + text-align: center; +} +div.sk-container { + display: inline-block; + position: relative; +} +""".replace(' ', '').replace('\n', '') # noqa + + +def estimator_html_repr(estimator): + """Build a HTML representation of an estimator. + + Read more in the :ref:`User Guide <visualizing_composite_estimators>`. + + Parameters + ---------- + estimator : estimator object + The estimator to visualize. + + Returns + ------- + html: str + HTML representation of estimator. + """ + with closing(StringIO()) as out: + out.write(f'<style>{_STYLE}</style>' + f'<div class="sk-top-container"><div class="sk-container">') + _write_estimator_html(out, estimator, estimator.__class__.__name__, + str(estimator), first_call=True) + out.write('</div></div>') + + html_output = out.getvalue() + return html_output

diff --git a/sklearn/tests/test_base.py b/sklearn/tests/test_base.py index 52f2e60b4af70..e20fa440d1933 100644 --- a/sklearn/tests/test_base.py +++ b/sklearn/tests/test_base.py @@ -23,6 +23,7 @@ from sklearn.base import TransformerMixin from sklearn.utils._mocking import MockDataFrame +from sklearn import config_context import pickle @@ -511,3 +512,16 @@ def fit(self, X, y=None): params = est.get_params() assert params['param'] is None + + +def test_repr_mimebundle_(): + # Checks the display configuration flag controls the json output + tree = DecisionTreeClassifier() + output = tree._repr_mimebundle_() + assert "text/plain" in output + assert "text/html" not in output + + with config_context(display='diagram'): + output = tree._repr_mimebundle_() + assert "text/plain" in output + assert "text/html" in output diff --git a/sklearn/tests/test_config.py b/sklearn/tests/test_config.py index ae13c61838694..eec349861258c 100644 --- a/sklearn/tests/test_config.py +++ b/sklearn/tests/test_config.py @@ -4,7 +4,8 @@ def test_config_context(): assert get_config() == {'assume_finite': False, 'working_memory': 1024, - 'print_changed_only': True} + 'print_changed_only': True, + 'display': 'text'} # Not using as a context manager affects nothing config_context(assume_finite=True) @@ -12,7 +13,8 @@ def test_config_context(): with config_context(assume_finite=True): assert get_config() == {'assume_finite': True, 'working_memory': 1024, - 'print_changed_only': True} + 'print_changed_only': True, + 'display': 'text'} assert get_config()['assume_finite'] is False with config_context(assume_finite=True): @@ -37,7 +39,8 @@ def test_config_context(): assert get_config()['assume_finite'] is True assert get_config() == {'assume_finite': False, 'working_memory': 1024, - 'print_changed_only': True} + 'print_changed_only': True, + 'display': 'text'} # No positional arguments assert_raises(TypeError, config_context, True) diff --git a/sklearn/utils/tests/test_estimator_html_repr.py b/sklearn/utils/tests/test_estimator_html_repr.py new file mode 100644 index 0000000000000..47d33051bd9a7 --- /dev/null +++ b/sklearn/utils/tests/test_estimator_html_repr.py @@ -0,0 +1,267 @@ +from contextlib import closing +from io import StringIO + +import pytest + +from sklearn import config_context +from sklearn.linear_model import LogisticRegression +from sklearn.neural_network import MLPClassifier +from sklearn.impute import SimpleImputer +from sklearn.decomposition import PCA +from sklearn.decomposition import TruncatedSVD +from sklearn.pipeline import Pipeline +from sklearn.pipeline import FeatureUnion +from sklearn.compose import ColumnTransformer +from sklearn.ensemble import VotingClassifier +from sklearn.feature_selection import SelectPercentile +from sklearn.cluster import Birch +from sklearn.cluster import AgglomerativeClustering +from sklearn.preprocessing import OneHotEncoder +from sklearn.svm import LinearSVC +from sklearn.svm import LinearSVR +from sklearn.tree import DecisionTreeClassifier +from sklearn.multiclass import OneVsOneClassifier +from sklearn.ensemble import StackingClassifier +from sklearn.ensemble import StackingRegressor +from sklearn.gaussian_process import GaussianProcessRegressor +from sklearn.gaussian_process.kernels import RationalQuadratic +from sklearn.utils._estimator_html_repr import _write_label_html +from sklearn.utils._estimator_html_repr import _get_visual_block +from sklearn.utils._estimator_html_repr import estimator_html_repr + + +@pytest.mark.parametrize("checked", [True, False]) +def test_write_label_html(checked): + # Test checking logic and labeling + name = "LogisticRegression" + tool_tip = "hello-world" + + with closing(StringIO()) as out: + _write_label_html(out, name, tool_tip, checked=checked) + html_label = out.getvalue() + assert 'LogisticRegression</label>' in html_label + assert html_label.startswith('<div class="sk-label-container">') + assert '<pre>hello-world</pre>' in html_label + if checked: + assert 'checked>' in html_label + + +@pytest.mark.parametrize('est', ['passthrough', 'drop', None]) +def test_get_visual_block_single_str_none(est): + # Test estimators that are represnted by strings + est_html_info = _get_visual_block(est) + assert est_html_info.kind == 'single' + assert est_html_info.estimators == est + assert est_html_info.names == str(est) + assert est_html_info.name_details == str(est) + + +def test_get_visual_block_single_estimator(): + est = LogisticRegression(C=10.0) + est_html_info = _get_visual_block(est) + assert est_html_info.kind == 'single' + assert est_html_info.estimators == est + assert est_html_info.names == est.__class__.__name__ + assert est_html_info.name_details == str(est) + + +def test_get_visual_block_pipeline(): + pipe = Pipeline([ + ('imputer', SimpleImputer()), + ('do_nothing', 'passthrough'), + ('do_nothing_more', None), + ('classifier', LogisticRegression()) + ]) + est_html_info = _get_visual_block(pipe) + assert est_html_info.kind == 'serial' + assert est_html_info.estimators == tuple(step[1] for step in pipe.steps) + assert est_html_info.names == ['imputer: SimpleImputer', + 'do_nothing: passthrough', + 'do_nothing_more: passthrough', + 'classifier: LogisticRegression'] + assert est_html_info.name_details == [str(est) for _, est in pipe.steps] + + +def test_get_visual_block_feature_union(): + f_union = FeatureUnion([ + ('pca', PCA()), ('svd', TruncatedSVD()) + ]) + est_html_info = _get_visual_block(f_union) + assert est_html_info.kind == 'parallel' + assert est_html_info.names == ('pca', 'svd') + assert est_html_info.estimators == tuple( + trans[1] for trans in f_union.transformer_list) + assert est_html_info.name_details == (None, None) + + +def test_get_visual_block_voting(): + clf = VotingClassifier([ + ('log_reg', LogisticRegression()), + ('mlp', MLPClassifier()) + ]) + est_html_info = _get_visual_block(clf) + assert est_html_info.kind == 'parallel' + assert est_html_info.estimators == tuple(trans[1] + for trans in clf.estimators) + assert est_html_info.names == ('log_reg', 'mlp') + assert est_html_info.name_details == (None, None) + + +def test_get_visual_block_column_transformer(): + ct = ColumnTransformer([ + ('pca', PCA(), ['num1', 'num2']), + ('svd', TruncatedSVD, [0, 3]) + ]) + est_html_info = _get_visual_block(ct) + assert est_html_info.kind == 'parallel' + assert est_html_info.estimators == tuple( + trans[1] for trans in ct.transformers) + assert est_html_info.names == ('pca', 'svd') + assert est_html_info.name_details == (['num1', 'num2'], [0, 3]) + + +def test_estimator_html_repr_pipeline(): + num_trans = Pipeline(steps=[ + ('pass', 'passthrough'), + ('imputer', SimpleImputer(strategy='median')) + ]) + + cat_trans = Pipeline(steps=[ + ('imputer', SimpleImputer(strategy='constant', + missing_values='empty')), + ('one-hot', OneHotEncoder(drop='first')) + ]) + + preprocess = ColumnTransformer([ + ('num', num_trans, ['a', 'b', 'c', 'd', 'e']), + ('cat', cat_trans, [0, 1, 2, 3]) + ]) + + feat_u = FeatureUnion([ + ('pca', PCA(n_components=1)), + ('tsvd', Pipeline([('first', TruncatedSVD(n_components=3)), + ('select', SelectPercentile())])) + ]) + + clf = VotingClassifier([ + ('lr', LogisticRegression(solver='lbfgs', random_state=1)), + ('mlp', MLPClassifier(alpha=0.001)) + ]) + + pipe = Pipeline([ + ('preprocessor', preprocess), ('feat_u', feat_u), ('classifier', clf) + ]) + html_output = estimator_html_repr(pipe) + + # top level estimators show estimator with changes + assert str(pipe) in html_output + for _, est in pipe.steps: + assert (f"<div class=\"sk-toggleable__content\">" + f"<pre>{str(est)}") in html_output + + # low level estimators do not show changes + with config_context(print_changed_only=True): + assert str(num_trans['pass']) in html_output + assert 'passthrough</label>' in html_output + assert str(num_trans['imputer']) in html_output + + for _, _, cols in preprocess.transformers: + assert f"<pre>{cols}</pre>" in html_output + + # feature union + for name, _ in feat_u.transformer_list: + assert f"<label>{name}</label>" in html_output + + pca = feat_u.transformer_list[0][1] + assert f"<pre>{str(pca)}</pre>" in html_output + + tsvd = feat_u.transformer_list[1][1] + first = tsvd['first'] + select = tsvd['select'] + assert f"<pre>{str(first)}</pre>" in html_output + assert f"<pre>{str(select)}</pre>" in html_output + + # voting classifer + for name, est in clf.estimators: + assert f"<label>{name}</label>" in html_output + assert f"<pre>{str(est)}</pre>" in html_output + + +@pytest.mark.parametrize("final_estimator", [None, LinearSVC()]) +def test_stacking_classsifer(final_estimator): + estimators = [('mlp', MLPClassifier(alpha=0.001)), + ('tree', DecisionTreeClassifier())] + clf = StackingClassifier( + estimators=estimators, final_estimator=final_estimator) + + html_output = estimator_html_repr(clf) + + assert str(clf) in html_output + # If final_estimator's default changes from LogisticRegression + # this should be updated + if final_estimator is None: + assert "LogisticRegression(" in html_output + else: + assert final_estimator.__class__.__name__ in html_output + + +@pytest.mark.parametrize("final_estimator", [None, LinearSVR()]) +def test_stacking_regressor(final_estimator): + reg = StackingRegressor( + estimators=[('svr', LinearSVR())], final_estimator=final_estimator) + html_output = estimator_html_repr(reg) + + assert str(reg.estimators[0][0]) in html_output + assert "LinearSVR</label>" in html_output + if final_estimator is None: + assert "RidgeCV</label>" in html_output + else: + assert final_estimator.__class__.__name__ in html_output + + +def test_birch_duck_typing_meta(): + # Test duck typing meta estimators with Birch + birch = Birch(n_clusters=AgglomerativeClustering(n_clusters=3)) + html_output = estimator_html_repr(birch) + + # inner estimators do not show changes + with config_context(print_changed_only=True): + assert f"<pre>{str(birch.n_clusters)}" in html_output + assert "AgglomerativeClustering</label>" in html_output + + # outer estimator contains all changes + assert f"<pre>{str(birch)}" in html_output + + +def test_ovo_classifier_duck_typing_meta(): + # Test duck typing metaestimators with OVO + ovo = OneVsOneClassifier(LinearSVC(penalty='l1')) + html_output = estimator_html_repr(ovo) + + # inner estimators do not show changes + with config_context(print_changed_only=True): + assert f"<pre>{str(ovo.estimator)}" in html_output + assert "LinearSVC</label>" in html_output + + # outter estimator + assert f"<pre>{str(ovo)}" in html_output + + +def test_duck_typing_nested_estimator(): + # Test duck typing metaestimators with GP + kernel = RationalQuadratic(length_scale=1.0, alpha=0.1) + gp = GaussianProcessRegressor(kernel=kernel) + html_output = estimator_html_repr(gp) + + assert f"<pre>{str(kernel)}" in html_output + assert f"<pre>{str(gp)}" in html_output + + +@pytest.mark.parametrize('print_changed_only', [True, False]) +def test_one_estimator_print_change_only(print_changed_only): + pca = PCA(n_components=10) + + with config_context(print_changed_only=print_changed_only): + pca_repr = str(pca) + html_output = estimator_html_repr(pca) + assert pca_repr in html_output

diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 3d9924638b69b..2489eaf55bac7 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -1569,6 +1569,7 @@ Plotting utils.deprecated utils.estimator_checks.check_estimator utils.estimator_checks.parametrize_with_checks + utils.estimator_html_repr utils.extmath.safe_sparse_dot utils.extmath.randomized_range_finder utils.extmath.randomized_svd diff --git a/doc/modules/compose.rst b/doc/modules/compose.rst index cd29b14b1f081..e7dac0dadc630 100644 --- a/doc/modules/compose.rst +++ b/doc/modules/compose.rst @@ -528,6 +528,31 @@ above example would be:: ('countvectorizer', CountVectorizer(), 'title')]) +.. _visualizing_composite_estimators: + +Visualizing Composite Estimators +================================ + +Estimators can be displayed with a HTML representation when shown in a +jupyter notebook. This can be useful to diagnose or visualize a Pipeline with +many estimators. This visualization is activated by setting the +`display` option in :func:`sklearn.set_config`:: + + >>> from sklearn import set_config + >>> set_config(display='diagram') # doctest: +SKIP + >>> # diplays HTML representation in a jupyter context + >>> column_trans # doctest: +SKIP + +An example of the HTML output can be seen in the +**HTML representation of Pipeline** section of +:ref:`sphx_glr_auto_examples_compose_plot_column_transformer_mixed_types.py`. +As an alternative, the HTML can be written to a file using +:func:`~sklearn.utils.estimator_html_repr`:: + + >>> from sklearn.utils import estimator_html_repr + >>> with open('my_estimator.html', 'w') as f: # doctest: +SKIP + ... f.write(estimator_html_repr(clf)) + .. topic:: Examples: * :ref:`sphx_glr_auto_examples_compose_plot_column_transformer.py` diff --git a/doc/whats_new/v0.23.rst b/doc/whats_new/v0.23.rst index 0e149ed03a9fa..1ac63ca473faf 100644 --- a/doc/whats_new/v0.23.rst +++ b/doc/whats_new/v0.23.rst @@ -567,6 +567,9 @@ Changelog :mod:`sklearn.utils` .................... +- |Feature| Adds :func:`utils.estimator_html_repr` for returning a + HTML representation of an estimator. :pr:`14180` by `Thomas Fan`_. + - |Enhancement| improve error message in :func:`utils.validation.column_or_1d`. :pr:`15926` by :user:`Loïc Estève <lesteve>`. @@ -605,6 +608,11 @@ Changelog Miscellaneous ............. +- |MajorFeature| Adds a HTML representation of estimators to be shown in + a jupyter notebook or lab. This visualization is acitivated by setting the + `display` option in :func:`sklearn.set_config`. :pr:`14180` by + `Thomas Fan`_. + - |Enhancement| ``scikit-learn`` now works with ``mypy`` without errors. :pr:`16726` by `Roman Yurchak`_.

[ { "components": [ { "doc": "HTML representation of estimator", "lines": [ 440, 442 ], "name": "BaseEstimator._repr_html_", "signature": "def _repr_html_(self):", "type": "function" }, { "doc": "Mime bundle used by jupy...

[ "sklearn/tests/test_base.py::test_clone", "sklearn/tests/test_base.py::test_clone_2", "sklearn/tests/test_base.py::test_clone_buggy", "sklearn/tests/test_base.py::test_clone_empty_array", "sklearn/tests/test_base.py::test_clone_nan", "sklearn/tests/test_base.py::test_clone_sparse_matrices", "sklearn/tes...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> ENH Adds HTML visualizations for estimators #### Reference Issues/PRs Closes https://github.com/scikit-learn/scikit-learn/issues/14061 #### What does this implement/fix? Explain your changes. You can demo the visualization here: https://thomasjpfan.github.io/sklearn_viz_html/index.html This PR implements a HTML visualization for estimators with a focus on displaying it in a Jupyter notebook or lab. This implementation is in pure HTML and CSS (no javascript or external dependencies): ![Screen Shot 2019-06-28 at 4 16 20 PM](https://user-images.githubusercontent.com/5402633/60368922-19f88a00-99c0-11e9-9397-06acf766390d.png) 1. We can hover over elements to see an estimators parameters (`print_changed_only=True` is the default for `export_html`): <img width="549" alt="Screen Shot 2019-06-24 at 10 11 36 PM" src="https://user-images.githubusercontent.com/5402633/60064008-14075e00-96cd-11e9-9fc1-c1b4c4de6484.png"> 2. All the labels in bold can be hovered over to get more information. 3. `_type_of_html_estimator` returns how to layout metaestimators, (`ColumnTransformer` and `FeatureUnion` is "parallel", while `Pipeline` is "serial") If there are any other metaestimators to add, we just need to add it to `_type_of_html_estimator`) 4. There is a hidden div `sk-final-spacer` as a hack to provide enough space for the information displayed while hovering over elements. <details> <summary>Code to Create HTML (In jupyterlab or a notebook)</summary> ```py from sklearn.compose import ColumnTransformer from sklearn.pipeline import Pipeline from sklearn.impute import SimpleImputer from sklearn.preprocessing import StandardScaler, OneHotEncoder from sklearn.linear_model import LogisticRegression from sklearn.decomposition import PCA, TruncatedSVD from sklearn.linear_model import LogisticRegression from sklearn.naive_bayes import GaussianNB from sklearn.ensemble import RandomForestClassifier, VotingClassifier from sklearn.pipeline import FeatureUnion from sklearn.feature_selection import SelectPercentile from sklearn.inspection import display_estimator # We create the preprocessing pipelines for both numeric and categorical data. numeric_features = ['age', 'fare'] numeric_transformer = Pipeline(steps=[ ('imputer', SimpleImputer(strategy='median'))]) feat_u2 = FeatureUnion([("pca", PCA(n_components=1)), ("svd", Pipeline([('tsvd1', TruncatedSVD(n_components=2)), ('select', SelectPercentile())]))]) numeric_transformer2 = Pipeline(steps=[ ('imputer', SimpleImputer(strategy='most_frequent')), ('scaler', StandardScaler(with_std=False)), ('feats', feat_u2) ]) categorical_features = ['embarked', 'sex', 'pclass'] categorical_transformer = Pipeline(steps=[ ('imputer', SimpleImputer(strategy='constant', missing_values="missing")), ('onehot', OneHotEncoder(handle_unknown='ignore', drop='first'))]) preprocessor = ColumnTransformer( transformers=[ ('num1', numeric_transformer, numeric_features), ('num2', numeric_transformer2, numeric_features), ('cat', categorical_transformer, categorical_features)]) feat_u = FeatureUnion([("pca", PCA(n_components=1, whiten=True, svd_solver='full')), ("svd", TruncatedSVD(n_components=2, n_iter=10))]) clf1 = LogisticRegression(solver='lbfgs', multi_class='multinomial', random_state=1, max_iter=200) clf2 = RandomForestClassifier(n_estimators=50, random_state=1, max_depth=8, warm_start=True, n_jobs=3, oob_score=True) clf3 = GaussianNB() eclf1 = VotingClassifier(estimators=[ ('lr', clf1), ('rf', clf2), ('gnb', clf3)], voting='hard') clf = Pipeline(steps=[('preprocessor', preprocessor), ('feat_u', feat_u), ('classifier', eclf1)]) display_estimator(clf) ``` </details> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/base.py] (definition of BaseEstimator._repr_html_:) def _repr_html_(self): """HTML representation of estimator""" (definition of BaseEstimator._repr_mimebundle_:) def _repr_mimebundle_(self, **kwargs): """Mime bundle used by jupyter kernels to display estimator""" [end of new definitions in sklearn/base.py] [start of new definitions in sklearn/compose/_column_transformer.py] (definition of ColumnTransformer._sk_visual_block_:) def _sk_visual_block_(self): [end of new definitions in sklearn/compose/_column_transformer.py] [start of new definitions in sklearn/ensemble/_stacking.py] (definition of _BaseStacking._sk_visual_block_:) def _sk_visual_block_(self, final_estimator): (definition of StackingClassifier._sk_visual_block_:) def _sk_visual_block_(self): (definition of StackingRegressor._sk_visual_block_:) def _sk_visual_block_(self): [end of new definitions in sklearn/ensemble/_stacking.py] [start of new definitions in sklearn/ensemble/_voting.py] (definition of _BaseVoting._sk_visual_block_:) def _sk_visual_block_(self): [end of new definitions in sklearn/ensemble/_voting.py] [start of new definitions in sklearn/pipeline.py] (definition of Pipeline._sk_visual_block_:) def _sk_visual_block_(self): (definition of Pipeline._sk_visual_block_._get_name:) def _get_name(name, est): (definition of FeatureUnion._sk_visual_block_:) def _sk_visual_block_(self): [end of new definitions in sklearn/pipeline.py] [start of new definitions in sklearn/utils/_estimator_html_repr.py] (definition of _VisualBlock:) class _VisualBlock: """HTML Representation of Estimator Parameters ---------- kind : {'serial', 'parallel', 'single'} kind of HTML block estimators : list of estimators or `_VisualBlock`s or a single estimator If kind != 'single', then `estimators` is a list of estimators. If kind == 'single', then `estimators` is a single estimator. names : list of str If kind != 'single', then `names` corresponds to estimators. If kind == 'single', then `names` is a single string corresponding to the single estimator. name_details : list of str, str, or None, default=None If kind != 'single', then `name_details` corresponds to `names`. If kind == 'single', then `name_details` is a single string corresponding to the single estimator. dash_wrapped : bool, default=True If true, wrapped HTML element will be wrapped with a dashed border. Only active when kind != 'single'.""" (definition of _VisualBlock.__init__:) def __init__(self, kind, estimators, *, names=None, name_details=None, dash_wrapped=True): (definition of _VisualBlock._sk_visual_block_:) def _sk_visual_block_(self): (definition of _write_label_html:) def _write_label_html(out, name, name_details, outer_class="sk-label-container", inner_class="sk-label", checked=False): """Write labeled html with or without a dropdown with named details""" (definition of _get_visual_block:) def _get_visual_block(estimator): """Generate information about how to display an estimator. """ (definition of _write_estimator_html:) def _write_estimator_html(out, estimator, estimator_label, estimator_label_details, first_call=False): """Write estimator to html in serial, parallel, or by itself (single). """ (definition of estimator_html_repr:) def estimator_html_repr(estimator): """Build a HTML representation of an estimator. Read more in the :ref:`User Guide <visualizing_composite_estimators>`. Parameters ---------- estimator : estimator object The estimator to visualize. Returns ------- html: str HTML representation of estimator.""" [end of new definitions in sklearn/utils/_estimator_html_repr.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

4bb4856ee8f3198740d53dd28b0b1d2767b90795

sympy__sympy-17078

17,078

sympy/sympy

1.5

f50c2d86a7be2003b26211971c3e335d59325348

2019-06-23T19:42:02Z

diff --git a/sympy/functions/__init__.py b/sympy/functions/__init__.py index bcacdc3c08f6..b43bfcd5914f 100644 --- a/sympy/functions/__init__.py +++ b/sympy/functions/__init__.py @@ -35,7 +35,7 @@ from sympy.functions.special.delta_functions import DiracDelta, Heaviside from sympy.functions.special.bsplines import bspline_basis, bspline_basis_set, interpolating_spline from sympy.functions.special.bessel import (besselj, bessely, besseli, besselk, - hankel1, hankel2, jn, yn, jn_zeros, hn1, hn2, airyai, airybi, airyaiprime, airybiprime) + hankel1, hankel2, jn, yn, jn_zeros, hn1, hn2, airyai, airybi, airyaiprime, airybiprime, marcumq) from sympy.functions.special.hyper import hyper, meijerg, appellf1 from sympy.functions.special.polynomials import (legendre, assoc_legendre, hermite, chebyshevt, chebyshevu, chebyshevu_root, chebyshevt_root, diff --git a/sympy/functions/special/bessel.py b/sympy/functions/special/bessel.py index c883cb8c8c43..6d043316ce30 100644 --- a/sympy/functions/special/bessel.py +++ b/sympy/functions/special/bessel.py @@ -1660,3 +1660,96 @@ def _eval_expand_func(self, **hints): pf = (d**m * z**(n*m)) / (d * z**n)**m newarg = c * d**m * z**(n*m) return S.Half * (sqrt(3)*(pf - S.One)*airyaiprime(newarg) + (pf + S.One)*airybiprime(newarg)) + + +class marcumq(Function): + r""" + The Marcum Q-function + + It is defined by the meromorphic continuation of + + .. math:: + Q_m(a, b) = a^{- m + 1} \int_{b}^{\infty} x^{m} e^{- \frac{a^{2}}{2} - \frac{x^{2}}{2}} I_{m - 1}\left(a x\right)\, dx + + Examples + ======== + + >>> from sympy import marcumq + >>> from sympy.abc import m, a, b, x + >>> marcumq(m, a, b) + marcumq(m, a, b) + + Special values: + + >>> marcumq(m, 0, b) + uppergamma(m, b**2/2)/gamma(m) + >>> marcumq(0, 0, 0) + 0 + >>> marcumq(0, a, 0) + 1 - exp(-a**2/2) + >>> marcumq(1, a, a) + 1/2 + exp(-a**2)*besseli(0, a**2)/2 + >>> marcumq(2, a, a) + 1/2 + exp(-a**2)*besseli(0, a**2)/2 + exp(-a**2)*besseli(1, a**2) + + Differentiation with respect to a and b is supported: + + >>> from sympy import diff + >>> diff(marcumq(m, a, b), a) + a*(-marcumq(m, a, b) + marcumq(m + 1, a, b)) + >>> diff(marcumq(m, a, b), b) + -a**(1 - m)*b**m*exp(-a**2/2 - b**2/2)*besseli(m - 1, a*b) + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Marcum_Q-function + .. [2] http://mathworld.wolfram.com/MarcumQ-Function.html + """ + + @classmethod + def eval(cls, m, a, b): + from sympy import exp, uppergamma + if a == 0: + if m == 0 and b == 0: + return S.Zero + return uppergamma(m, b**2 / 2) / gamma(m) + + if m == 0 and b == 0: + return 1 - 1 / exp(a**2 / 2) + + if a == b: + if m == 1: + return (1 + exp(-a**2) * besseli(0, a**2)) / 2 + if m == 2: + return S.Half + S.Half * exp(-a**2) * besseli(0, a**2) + exp(-a**2) * besseli(1, a**2) + + def fdiff(self, argindex=2): + from sympy import exp + m, a, b = self.args + if argindex == 2: + return a * (-marcumq(m, a, b) + marcumq(1+m, a, b)) + elif argindex == 3: + return (-b**m / a**(m-1)) * exp(-(a**2 + b**2)/2) * besseli(m-1, a*b) + else: + raise ArgumentIndexError(self, argindex) + + def _eval_rewrite_as_Integral(self, m, a, b, **kwargs): + from sympy import Integral, exp, Dummy, oo + x = kwargs.get('x', Dummy('x')) + return a ** (1 - m) * \ + Integral(x**m * exp(-(x**2 + a**2)/2) * besseli(m-1, a*x), [x, b, oo]) + + def _eval_rewrite_as_Sum(self, m, a, b, **kwargs): + from sympy import Sum, exp, Dummy, oo + k = kwargs.get('k', Dummy('k')) + return exp(-(a**2 + b**2) / 2) * Sum((a/b)**k * besseli(k, a*b), [k, 1-m, oo]) + + def _eval_rewrite_as_besseli(self, m, a, b, **kwargs): + if a == b: + from sympy import exp + if m == 1: + return (1 + exp(-a**2) * besseli(0, a**2)) / 2 + if m.is_Integer and m >= 2: + s = sum([besseli(i, a**2) for i in range(1, m)]) + return S.Half + exp(-a**2) * besseli(0, a**2) / 2 + exp(-a**2) * s

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index a8f7f03755c2..879023ea2c38 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -2064,6 +2064,11 @@ def test_sympy__functions__special__bessel__airybiprime(): assert _test_args(airybiprime(2)) +def test_sympy__functions__special__bessel__marcumq(): + from sympy.functions.special.bessel import marcumq + assert _test_args(marcumq(x, y, z)) + + def test_sympy__functions__special__elliptic_integrals__elliptic_k(): from sympy.functions.special.elliptic_integrals import elliptic_k as K assert _test_args(K(x)) diff --git a/sympy/functions/special/tests/test_bessel.py b/sympy/functions/special/tests/test_bessel.py index e9e25f0f59b3..80d4d6332dc0 100644 --- a/sympy/functions/special/tests/test_bessel.py +++ b/sympy/functions/special/tests/test_bessel.py @@ -3,10 +3,10 @@ from sympy import (jn, yn, symbols, Symbol, sin, cos, pi, S, jn_zeros, besselj, bessely, besseli, besselk, hankel1, hankel2, hn1, hn2, expand_func, sqrt, sinh, cosh, diff, series, gamma, hyper, - Abs, I, O, oo, conjugate) + Abs, I, O, oo, conjugate, uppergamma, exp, Integral, Sum) from sympy.functions.special.bessel import fn from sympy.functions.special.bessel import (airyai, airybi, - airyaiprime, airybiprime) + airyaiprime, airybiprime, marcumq) from sympy.utilities.randtest import (random_complex_number as randcplx, verify_numerically as tn, test_derivative_numerically as td, @@ -557,3 +557,44 @@ def test_airybiprime(): assert expand_func(airybiprime(2*(3*z**5)**(S(1)/3))) == ( sqrt(3)*(z**(S(5)/3)/(z**5)**(S(1)/3) - 1)*airyaiprime(2*3**(S(1)/3)*z**(S(5)/3))/2 + (z**(S(5)/3)/(z**5)**(S(1)/3) + 1)*airybiprime(2*3**(S(1)/3)*z**(S(5)/3))/2) + + +def test_marcumq(): + m = Symbol('m') + a = Symbol('a') + b = Symbol('b') + + assert marcumq(0, 0, 0) == 0 + assert marcumq(m, 0, b) == uppergamma(m, b**2/2)/gamma(m) + assert marcumq(2, 0, 5) == 27*exp(-S(25)/2)/2 + assert marcumq(0, a, 0) == 1 - exp(-a**2/2) + assert marcumq(0, pi, 0) == 1 - exp(-pi**2/2) + assert marcumq(1, a, a) == S.Half + exp(-a**2)*besseli(0, a**2)/2 + assert marcumq(2, a, a) == S.Half + exp(-a**2)*besseli(0, a**2)/2 + exp(-a**2)*besseli(1, a**2) + + assert diff(marcumq(1, a, 3), a) == a*(-marcumq(1, a, 3) + marcumq(2, a, 3)) + assert diff(marcumq(2, 3, b), b) == -b**2*exp(-b**2/2 - S(9)/2)*besseli(1, 3*b)/3 + + x = Symbol('x') + assert marcumq(2, 3, 4).rewrite(Integral, x=x) == \ + Integral(x**2*exp(-x**2/2 - S(9)/2)*besseli(1, 3*x), (x, 4, oo))/3 + assert eq([marcumq(5, -2, 3).rewrite(Integral).evalf(10)], + [0.7905769565]) + + k = Symbol('k') + assert marcumq(-3, -5, -7).rewrite(Sum, k=k) == \ + exp(-37)*Sum((S(5)/7)**k*besseli(k, 35), (k, 4, oo)) + assert eq([marcumq(1, 3, 1).rewrite(Sum).evalf(10)], + [0.9891705502]) + + assert marcumq(1, a, a, evaluate=False).rewrite(besseli) == S.Half + exp(-a**2)*besseli(0, a**2)/2 + assert marcumq(2, a, a, evaluate=False).rewrite(besseli) == S.Half + exp(-a**2)*besseli(0, a**2)/2 + \ + exp(-a**2)*besseli(1, a**2) + assert marcumq(3, a, a).rewrite(besseli) == (besseli(1, a**2) + besseli(2, a**2))*exp(-a**2) + \ + S.Half + exp(-a**2)*besseli(0, a**2)/2 + assert marcumq(5, 8, 8).rewrite(besseli) == exp(-64)*besseli(0, 64)/2 + \ + (besseli(4, 64) + besseli(3, 64) + besseli(2, 64) + besseli(1, 64))*exp(-64) + S.Half + assert marcumq(m, a, a).rewrite(besseli) == marcumq(m, a, a) + + x = Symbol('x', integer=True) + assert marcumq(x, a, a).rewrite(besseli) == marcumq(x, a, a)

[ { "components": [ { "doc": "The Marcum Q-function\n\nIt is defined by the meromorphic continuation of\n\n.. math::\n Q_m(a, b) = a^{- m + 1} \\int_{b}^{\\infty} x^{m} e^{- \\frac{a^{2}}{2} - \\frac{x^{2}}{2}} I_{m - 1}\\left(a x\\right)\\, dx\n\nExamples\n========\n\n>>> from sympy import marcu...

[ "test_sympy__functions__special__bessel__marcumq", "test_bessel_rand", "test_bessel_twoinputs", "test_diff", "test_rewrite", "test_expand", "test_fn", "test_jn", "test_yn", "test_sympify_yn", "test_jn_zeros", "test_bessel_eval", "test_bessel_nan", "test_conjugate", "test_branching", "t...

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add Marcum Q-function Closes #17073. #### Brief description of what is fixed or changed Added [Marcum Q-function](http://mathworld.wolfram.com/MarcumQ-Function.html) to `bessel.py`, with differentiation and some special values. Also implemented rewriting as a sum of Bessel functions. #### Release Notes  * functions * Added Marcum Q-function.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/functions/special/bessel.py] (definition of marcumq:) class marcumq(Function): """The Marcum Q-function It is defined by the meromorphic continuation of .. math:: Q_m(a, b) = a^{- m + 1} \int_{b}^{\infty} x^{m} e^{- \frac{a^{2}}{2} - \frac{x^{2}}{2}} I_{m - 1}\left(a x\right)\, dx Examples ======== >>> from sympy import marcumq >>> from sympy.abc import m, a, b, x >>> marcumq(m, a, b) marcumq(m, a, b) Special values: >>> marcumq(m, 0, b) uppergamma(m, b**2/2)/gamma(m) >>> marcumq(0, 0, 0) 0 >>> marcumq(0, a, 0) 1 - exp(-a**2/2) >>> marcumq(1, a, a) 1/2 + exp(-a**2)*besseli(0, a**2)/2 >>> marcumq(2, a, a) 1/2 + exp(-a**2)*besseli(0, a**2)/2 + exp(-a**2)*besseli(1, a**2) Differentiation with respect to a and b is supported: >>> from sympy import diff >>> diff(marcumq(m, a, b), a) a*(-marcumq(m, a, b) + marcumq(m + 1, a, b)) >>> diff(marcumq(m, a, b), b) -a**(1 - m)*b**m*exp(-a**2/2 - b**2/2)*besseli(m - 1, a*b) References ========== .. [1] https://en.wikipedia.org/wiki/Marcum_Q-function .. [2] http://mathworld.wolfram.com/MarcumQ-Function.html""" (definition of marcumq.eval:) def eval(cls, m, a, b): (definition of marcumq.fdiff:) def fdiff(self, argindex=2): (definition of marcumq._eval_rewrite_as_Integral:) def _eval_rewrite_as_Integral(self, m, a, b, **kwargs): (definition of marcumq._eval_rewrite_as_Sum:) def _eval_rewrite_as_Sum(self, m, a, b, **kwargs): (definition of marcumq._eval_rewrite_as_besseli:) def _eval_rewrite_as_besseli(self, m, a, b, **kwargs): [end of new definitions in sympy/functions/special/bessel.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Implement Marcum Q-function The Marcum Q-function is used as a cumulative distribution function (more precisely, as a survivor function) for noncentral chi, noncentral chi-squared and Rice distributions. This function also arises in performance analysis of partially coherent, differentially coherent, and noncoherent communications. References: [1] [wiki](https://en.wikipedia.org/wiki/Marcum_Q-function) [2] [wolfram](http://mathworld.wolfram.com/MarcumQ-Function.html) <img width="454" alt="MarcumQ" src="https://user-images.githubusercontent.com/34616054/59972653-a7973c80-95b0-11e9-9494-0b0976e68adf.png"> ---------- Where would it be located- in `bessel.py`? Yes, I too think that it should be located in `bessel.py` since it uses `besseli` function. -------------------- </issues>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-17077

17,077

sympy/sympy

1.5

e6a5b6cb700f9aee594d80bea058ca19a95551cc

2019-06-23T18:49:41Z

diff --git a/sympy/stats/__init__.py b/sympy/stats/__init__.py index 5364fce2185d..635094919db9 100644 --- a/sympy/stats/__init__.py +++ b/sympy/stats/__init__.py @@ -42,7 +42,7 @@ from . import rv_interface from .rv_interface import ( cdf, characteristic_function, covariance, density, dependent, E, given, independent, P, pspace, - random_symbols, sample, sample_iter, skewness, kurtosis, std, variance, where, + random_symbols, sample, sample_iter, skewness, kurtosis, std, variance, where, factorial_moment, correlation, moment, cmoment, smoment, sampling_density, moment_generating_function, entropy, H, quantile ) diff --git a/sympy/stats/rv_interface.py b/sympy/stats/rv_interface.py index 18050b356e71..c87dd79e75e4 100644 --- a/sympy/stats/rv_interface.py +++ b/sympy/stats/rv_interface.py @@ -1,13 +1,13 @@ from __future__ import print_function, division -from sympy import sqrt, Symbol, log, exp +from sympy import sqrt, Symbol, log, exp, FallingFactorial from .rv import (probability, expectation, density, where, given, pspace, cdf, characteristic_function, sample, sample_iter, random_symbols, independent, dependent, sampling_density, moment_generating_function, quantile) __all__ = ['P', 'E', 'H', 'density', 'where', 'given', 'sample', 'cdf', 'characteristic_function', 'pspace', 'sample_iter', 'variance', 'std', 'skewness', 'kurtosis', 'covariance', - 'dependent', 'independent', 'random_symbols', 'correlation', + 'dependent', 'independent', 'random_symbols', 'correlation', 'factorial_moment', 'moment', 'cmoment', 'sampling_density', 'moment_generating_function', 'quantile'] @@ -292,12 +292,50 @@ def kurtosis(X, condition=None, **kwargs): References ========== + .. [1] https://en.wikipedia.org/wiki/Kurtosis .. [2] http://mathworld.wolfram.com/Kurtosis.html """ return smoment(X, 4, condition=condition, **kwargs) +def factorial_moment(X, n, condition=None, **kwargs): + """ + The factorial moment is a mathematical quantity defined as the expectation + or average of the falling factorial of a random variable. + + factorial_moment(X, n) = E(X*(X - 1)*(X - 2)*...*(X - n + 1)) + + Parameters + ========== + + n: A natural number, n-th factorial moment. + + condition : Expr containing RandomSymbols + A conditional expression. + + Examples + ======== + + >>> from sympy.stats import factorial_moment, Poisson, Binomial + >>> from sympy import Symbol, S + >>> lamda = Symbol('lamda') + >>> X = Poisson('X', lamda) + >>> factorial_moment(X, 2) + lamda**2 + >>> Y = Binomial('Y', 2, S.Half) + >>> factorial_moment(Y, 2) + 1/2 + >>> factorial_moment(Y, 2, Y > 1) # find factorial moment for Y > 1 + 2 + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Factorial_moment + .. [2] http://mathworld.wolfram.com/FactorialMoment.html + """ + return expectation(FallingFactorial(X, n), condition=condition, **kwargs) P = probability

diff --git a/sympy/stats/tests/test_rv.py b/sympy/stats/tests/test_rv.py index 417fe79b5c6b..2f4a53fe3464 100644 --- a/sympy/stats/tests/test_rv.py +++ b/sympy/stats/tests/test_rv.py @@ -1,11 +1,11 @@ -from sympy import (S, Symbol, Interval, +from sympy import (S, Symbol, symbols, Interval, FallingFactorial, Eq, cos, And, Tuple, integrate, oo, sin, Sum, Basic, DiracDelta, log, pi) from sympy.core.compatibility import range from sympy.core.numbers import comp from sympy.stats import (Die, Normal, Exponential, FiniteRV, P, E, H, variance, - density, given, independent, dependent, where, pspace, - random_symbols, sample, Geometric) + density, given, independent, dependent, where, pspace, factorial_moment, + random_symbols, sample, Geometric, Binomial, Poisson, Hypergeometric) from sympy.stats.frv_types import BernoulliDistribution from sympy.stats.rv import (IndependentProductPSpace, rs_swap, Density, NamedArgsMixin, RandomSymbol, PSpace) @@ -152,6 +152,24 @@ def test_given(): assert X == A == B +def test_factorial_moment(): + X = Poisson('X', 2) + Y = Binomial('Y', 2, S.Half) + Z = Hypergeometric('Z', 4, 2, 2) + assert factorial_moment(X, 2) == 4 + assert factorial_moment(Y, 2) == S(1)/2 + assert factorial_moment(Z, 2) == S(1)/3 + + x, y, z, l = symbols('x y z l') + Y = Binomial('Y', 2, y) + Z = Hypergeometric('Z', 10, 2, 3) + assert factorial_moment(Y, l) == y**2*FallingFactorial( + 2, l) + 2*y*(1 - y)*FallingFactorial(1, l) + (1 - y)**2*\ + FallingFactorial(0, l) + assert factorial_moment(Z, l) == 7*FallingFactorial(0, l)/\ + 15 + 7*FallingFactorial(1, l)/15 + FallingFactorial(2, l)/15 + + def test_dependence(): X, Y = Die('X'), Die('Y') assert independent(X, 2*Y)

[ { "components": [ { "doc": "The factorial moment is a mathematical quantity defined as the expectation\nor average of the falling factorial of a random variable.\n\nfactorial_moment(X, n) = E(X*(X - 1)*(X - 2)*...*(X - n + 1))\n\nParameters\n==========\n\nn: A natural number, n-th factorial moment...

[ "test_where", "test_random_symbols", "test_pspace", "test_rs_swap", "test_RandomSymbol", "test_RandomSymbol_diff", "test_random_symbol_no_pspace", "test_overlap", "test_IndependentProductPSpace", "test_E", "test_H", "test_Sample", "test_given", "test_factorial_moment", "test_dependence",...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added Factorial Moment  #### References to other Issues or PRs  Added factorial moment under `sympy/stats/rv_interface.py` #### Brief description of what is fixed or changed #### Other comments Ping @sidhantnagpal #### Release Notes   - stats - Added factorial moment function under `sympy/stats/rv_interface.py`  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/rv_interface.py] (definition of factorial_moment:) def factorial_moment(X, n, condition=None, **kwargs): """The factorial moment is a mathematical quantity defined as the expectation or average of the falling factorial of a random variable. factorial_moment(X, n) = E(X*(X - 1)*(X - 2)*...*(X - n + 1)) Parameters ========== n: A natural number, n-th factorial moment. condition : Expr containing RandomSymbols A conditional expression. Examples ======== >>> from sympy.stats import factorial_moment, Poisson, Binomial >>> from sympy import Symbol, S >>> lamda = Symbol('lamda') >>> X = Poisson('X', lamda) >>> factorial_moment(X, 2) lamda**2 >>> Y = Binomial('Y', 2, S.Half) >>> factorial_moment(Y, 2) 1/2 >>> factorial_moment(Y, 2, Y > 1) # find factorial moment for Y > 1 2 References ========== .. [1] https://en.wikipedia.org/wiki/Factorial_moment .. [2] http://mathworld.wolfram.com/FactorialMoment.html""" [end of new definitions in sympy/stats/rv_interface.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-17075

17,075

sympy/sympy

1.5

3729e1ba5a2afcfc3ceee7b98b07d5b57303f919

2019-06-23T12:43:58Z

diff --git a/sympy/printing/mathml.py b/sympy/printing/mathml.py index e5012efe74d8..3e48f1365f9e 100644 --- a/sympy/printing/mathml.py +++ b/sympy/printing/mathml.py @@ -741,6 +741,53 @@ def _print_NegativeInfinity(self, e): mrow.appendChild(x) return mrow + def _print_HBar(self, e): + x = self.dom.createElement('mi') + x.appendChild(self.dom.createTextNode('ℏ')) + return x + + def _print_EulerGamma(self, e): + x = self.dom.createElement('mi') + x.appendChild(self.dom.createTextNode('γ')) + return x + + def _print_TribonacciConstant(self, e): + x = self.dom.createElement('mi') + x.appendChild(self.dom.createTextNode('TribonacciConstant')) + return x + + def _print_Dagger(self, e): + msup = self.dom.createElement('msup') + msup.appendChild(self._print(e.args[0])) + msup.appendChild(self.dom.createTextNode('†')) + return msup + + def _print_Contains(self, e): + mrow = self.dom.createElement('mrow') + mrow.appendChild(self._print(e.args[0])) + mo = self.dom.createElement('mo') + mo.appendChild(self.dom.createTextNode('∈')) + mrow.appendChild(mo) + mrow.appendChild(self._print(e.args[1])) + return mrow + + def _print_HilbertSpace(self, e): + x = self.dom.createElement('mi') + x.appendChild(self.dom.createTextNode('ℋ')) + return x + + def _print_ComplexSpace(self, e): + msup = self.dom.createElement('msup') + msup.appendChild(self.dom.createTextNode('𝒞')) + msup.appendChild(self._print(e.args[0])) + return msup + + def _print_FockSpace(self, e): + x = self.dom.createElement('mi') + x.appendChild(self.dom.createTextNode('ℱ')) + return x + + def _print_Integral(self, expr): intsymbols = {1: "∫", 2: "∬", 3: "∭"}

diff --git a/sympy/printing/tests/test_mathml.py b/sympy/printing/tests/test_mathml.py index 4aed2e33394d..7e57d6a157be 100644 --- a/sympy/printing/tests/test_mathml.py +++ b/sympy/printing/tests/test_mathml.py @@ -4,7 +4,7 @@ S, MatrixSymbol, Function, Derivative, log, true, false, Range, Min, Max, \ Lambda, IndexedBase, symbols, zoo, elliptic_f, elliptic_e, elliptic_pi, Ei, \ expint, jacobi, gegenbauer, chebyshevt, chebyshevu, legendre, assoc_legendre, \ - laguerre, assoc_laguerre, hermite + laguerre, assoc_laguerre, hermite, TribonacciConstant, EulerGamma, Contains from sympy import elliptic_k, totient, reduced_totient, primenu, primeomega, \ fresnelc, fresnels, Heaviside @@ -22,6 +22,7 @@ from sympy.functions.special.zeta_functions import polylog, lerchphi, zeta, dirichlet_eta from sympy.logic.boolalg import And, Or, Implies, Equivalent, Xor, Not from sympy.matrices.expressions.determinant import Determinant +from sympy.physics.quantum import ComplexSpace, HilbertSpace, FockSpace, hbar, Dagger from sympy.printing.mathml import mathml, MathMLContentPrinter, \ MathMLPresentationPrinter, MathMLPrinter from sympy.sets.sets import FiniteSet, Union, Intersection, Complement, \ @@ -1141,6 +1142,27 @@ def test_print_UniversalSet(): assert mpp.doprint(S.UniversalSet) == '<mo>𝕌</mo>' +def test_print_spaces(): + assert mpp.doprint(HilbertSpace()) == '<mi>ℋ</mi>' + assert mpp.doprint(ComplexSpace(2)) == '<msup>𝒞<mn>2</mn></msup>' + assert mpp.doprint(FockSpace()) == '<mi>ℱ</mi>' + + +def test_print_constants(): + assert mpp.doprint(hbar) == '<mi>ℏ</mi>' + assert mpp.doprint(TribonacciConstant) == '<mi>TribonacciConstant</mi>' + assert mpp.doprint(EulerGamma) == '<mi>γ</mi>' + + +def test_print_Contains(): + assert mpp.doprint(Contains(x, S.Naturals)) == \ + '<mrow><mi>x</mi><mo>∈</mo><mi mathvariant="normal">ℕ</mi></mrow>' + + +def test_print_Dagger(): + assert mpp.doprint(Dagger(x)) == '<msup><mi>x</mi>†</msup>' + + def test_print_SetOp(): f1 = FiniteSet(x, 1, 3) f2 = FiniteSet(y, 2, 4)

[ { "components": [ { "doc": "", "lines": [ 744, 747 ], "name": "MathMLPresentationPrinter._print_HBar", "signature": "def _print_HBar(self, e):", "type": "function" }, { "doc": "", "lines": [ 749, ...

[ "test_print_spaces", "test_print_constants", "test_print_Contains", "test_print_Dagger" ]

[ "test_mathml_printer", "test_content_printmethod", "test_content_mathml_core", "test_content_mathml_functions", "test_content_mathml_limits", "test_content_mathml_integrals", "test_content_mathml_matrices", "test_content_mathml_sums", "test_content_mathml_tuples", "test_content_mathml_add", "tes...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added some MathML presentation printing methods  #### References to other Issues or PRs  Related to #16036 #### Brief description of what is fixed or changed Added printing of some constants, spaces, and functions. Before: <img width="578" alt="beforeconstants" src="https://user-images.githubusercontent.com/8114497/59976459-28603380-95c5-11e9-877c-61cf5cd40c7a.PNG"> After: <img width="563" alt="afterconstants" src="https://user-images.githubusercontent.com/8114497/59976461-2f874180-95c5-11e9-813f-0b24d05d1c16.PNG"> #### Other comments #### Release Notes   * printing * Added MathML presentation printing of some constants and spaces. * Added MathML presentation printing of `Contains` and `Dagger`.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/printing/mathml.py] (definition of MathMLPresentationPrinter._print_HBar:) def _print_HBar(self, e): (definition of MathMLPresentationPrinter._print_EulerGamma:) def _print_EulerGamma(self, e): (definition of MathMLPresentationPrinter._print_TribonacciConstant:) def _print_TribonacciConstant(self, e): (definition of MathMLPresentationPrinter._print_Dagger:) def _print_Dagger(self, e): (definition of MathMLPresentationPrinter._print_Contains:) def _print_Contains(self, e): (definition of MathMLPresentationPrinter._print_HilbertSpace:) def _print_HilbertSpace(self, e): (definition of MathMLPresentationPrinter._print_ComplexSpace:) def _print_ComplexSpace(self, e): (definition of MathMLPresentationPrinter._print_FockSpace:) def _print_FockSpace(self, e): [end of new definitions in sympy/printing/mathml.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-17064

17,064

sympy/sympy

1.5

411757c159e16a56b5ad8141cb07dc32f4277caa

2019-06-20T19:56:16Z

diff --git a/sympy/series/formal.py b/sympy/series/formal.py index 2065b385f46f..c6a6f1a225fa 100644 --- a/sympy/series/formal.py +++ b/sympy/series/formal.py @@ -18,6 +18,7 @@ from sympy.core.sympify import sympify from sympy.discrete.convolutions import convolution from sympy.functions.combinatorial.factorials import binomial, factorial, rf +from sympy.functions.combinatorial.numbers import bell from sympy.functions.elementary.integers import floor, frac, ceiling from sympy.functions.elementary.miscellaneous import Min, Max from sympy.functions.elementary.piecewise import Piecewise @@ -943,6 +944,14 @@ def __new__(cls, *args): args = map(sympify, args) return Expr.__new__(cls, *args) + def __init__(self, *args): + ak = args[4][0] + k = ak.variables[0] + self.ak_seq = sequence(ak.formula, (k, 1, oo)) + self.fact_seq = sequence(factorial(k), (k, 1, oo)) + self.bell_coeff_seq = self.ak_seq * self.fact_seq + self.sign_seq = sequence((-1, 1), (k, 1, oo)) + @property def function(self): return self.args[0] @@ -1171,6 +1180,7 @@ def product(self, other, x=None, n=6): sympy.discrete.convolutions """ + if x is None: x = self.x if n is None: @@ -1178,7 +1188,7 @@ def product(self, other, x=None, n=6): other = sympify(other) - if not isinstance(other, FormalPowerSeries): + if not isinstance(other, FormalPowerSeries): raise ValueError("Both series should be an instance of FormalPowerSeries" " class.") @@ -1207,6 +1217,186 @@ def product(self, other, x=None, n=6): return Add(*(terms_seq[:n])) + Order(self.xk.coeff(n), (self.x, self.x0)) + def coeff_bell(self, n): + r""" + self.coeff_bell(n) returns a sequence of Bell polynomials of the second kind. + Note that ``n`` should be a integer. + + The second kind of Bell polynomials (are sometimes called "partial" Bell + polynomials or incomplete Bell polynomials) are defined as + + .. math:: B_{n,k}(x_1, x_2,\dotsc x_{n-k+1}) = + \sum_{j_1+j_2+j_2+\dotsb=k \atop j_1+2j_2+3j_2+\dotsb=n} + \frac{n!}{j_1!j_2!\dotsb j_{n-k+1}!} + \left(\frac{x_1}{1!} \right)^{j_1} + \left(\frac{x_2}{2!} \right)^{j_2} \dotsb + \left(\frac{x_{n-k+1}}{(n-k+1)!} \right) ^{j_{n-k+1}}. + + * ``bell(n, k, (x1, x2, ...))`` gives Bell polynomials of the second kind, + `B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1})`. + + See Also + ======== + + sympy.functions.combinatorial.numbers.bell + + """ + + inner_coeffs = [bell(n, j, tuple(self.bell_coeff_seq[:n-j+1])) for j in range(1, n+1)] + + k = Dummy('k') + return sequence(tuple(inner_coeffs), (k, 1, oo)) + + def compose(self, other, x=None, n=6): + r""" + Returns the truncated terms of the formal power series of the composed function, + up to specified `n`. + + If `f` and `g` are two formal power series of two different functions, + then the coefficient sequence ``ak`` of the composed formal power series `fp` + will be as follows. + + .. math:: + + \sum\limits_{k=0}^{n} b_k B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1}) + + Parameters + ========== + + n : Number, optional + Specifies the order of the term up to which the polynomial should + be truncated. + + Examples + ======== + + >>> from sympy import fps, sin, exp, bell + >>> from sympy.abc import x + >>> f1 = fps(exp(x)) + >>> f2 = fps(sin(x)) + + >>> f1.compose(f2, x) + 1 + x + x**2/2 - x**4/8 - x**5/15 + O(x**6) + + >>> f1.compose(f2, x, n=8) + 1 + x + x**2/2 - x**4/8 - x**5/15 - x**6/240 + x**7/90 + O(x**8) + + See Also + ======== + + sympy.functions.combinatorial.numbers.bell + + References + ========== + + .. [1] Comtet, Louis: Advanced combinatorics; the art of finite and infinite expansions. Reidel, 1974. + + """ + + if x is None: + x = self.x + if n is None: + return iter(self) + + other = sympify(other) + + if not isinstance(other, FormalPowerSeries): + raise ValueError("Both series should be an instance of FormalPowerSeries" + " class.") + + if self.dir != other.dir: + raise ValueError("Both series should be calculated from the" + " same direction.") + elif self.x0 != other.x0: + raise ValueError("Both series should be calculated about the" + " same point.") + + elif self.x != other.x: + raise ValueError("Both series should have the same symbol.") + + f, g = self.function, other.function + if other._eval_term(0).as_coeff_mul(other.x)[0] is not S.Zero: + raise ValueError("The formal power series of the inner function should not have any " + "constant coefficient term.") + + terms = [] + + for i in range(1, n): + bell_seq = other.coeff_bell(i) + seq = (self.bell_coeff_seq * bell_seq) + terms.append(Add(*(seq[:i])) * self.xk.coeff(i) / self.fact_seq[i-1]) + + return self._eval_term(0) + Add(*terms) + Order(self.xk.coeff(n), (self.x, self.x0)) + + def inverse(self, x=None, n=6): + r""" + Returns the truncated terms of the inverse of the formal power series, + up to specified `n`. + + If `f` and `g` are two formal power series of two different functions, + then the coefficient sequence ``ak`` of the composed formal power series `fp` + will be as follows. + + .. math:: + + \sum\limits_{k=0}^{n} (-1)^{k} x_0^{-k-1} B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1}) + + Parameters + ========== + + n : Number, optional + Specifies the order of the term up to which the polynomial should + be truncated. + + Examples + ======== + + >>> from sympy import fps, exp, cos, bell + >>> from sympy.abc import x + >>> f1 = fps(exp(x)) + >>> f2 = fps(cos(x)) + + >>> f1.inverse(x) + 1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + O(x**6) + + >>> f2.inverse(x, n=8) + 1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + O(x**8) + + See Also + ======== + + sympy.functions.combinatorial.numbers.bell + + References + ========== + + .. [1] Comtet, Louis: Advanced combinatorics; the art of finite and infinite expansions. Reidel, 1974. + + """ + + if x is None: + x = self.x + if n is None: + return iter(self) + + f = self.function + if self._eval_term(0) is S.Zero: + raise ValueError("Constant coefficient should exist for an inverse of a formal" + " power series to exist.") + inv = self._eval_term(0) + + k = Dummy('k') + terms = [] + inv_seq = sequence(inv ** (-(k + 1)), (k, 1, oo)) + aux_seq = self.sign_seq * self.fact_seq * inv_seq + + for i in range(1, n): + bell_seq = self.coeff_bell(i) + seq = (aux_seq * bell_seq) + terms.append(Add(*(seq[:i])) * self.xk.coeff(i) / self.fact_seq[i-1]) + + return self._eval_term(0) + Add(*terms) + Order(self.xk.coeff(n), (self.x, self.x0)) + def __add__(self, other): other = sympify(other)

diff --git a/sympy/series/tests/test_formal.py b/sympy/series/tests/test_formal.py index 233e3382a7ef..86626c1ea332 100644 --- a/sympy/series/tests/test_formal.py +++ b/sympy/series/tests/test_formal.py @@ -519,3 +519,35 @@ def test_fps__convolution(): assert f1.product(f2, x, 3) == x + x**2 + O(x**3) assert f1.product(f2, x, 4) == x + x**2 + x**3/3 + O(x**4) assert f1.product(f3, x, 4) == x - 2*x**3/3 + O(x**4) + +def test_fps__composition(): + f1, f2, f3 = fps(exp(x)), fps(sin(x)), fps(cos(x)) + + raises(ValueError, lambda: f1.compose(sin(x), x)) + raises(ValueError, lambda: f1.compose(fps(sin(x), dir=-1), x, 4)) + raises(ValueError, lambda: f1.compose(fps(sin(x), x0=1), x, 4)) + raises(ValueError, lambda: f1.compose(fps(sin(y)), x, 4)) + + raises(ValueError, lambda: f1.compose(f3, x)) + raises(ValueError, lambda: f2.compose(f3, x)) + + assert f1.compose(f2, x) == 1 + x + x**2/2 - x**4/8 - x**5/15 + O(x**6) + assert f1.compose(f2, x, n=4) == 1 + x + x**2/2 + O(x**4) + assert f1.compose(f2, x, n=8) == \ + 1 + x + x**2/2 - x**4/8 - x**5/15 - x**6/240 + x**7/90 + O(x**8) + + assert f2.compose(f2, x, n=4) == x - x**3/3 + O(x**4) + assert f2.compose(f2, x, n=8) == x - x**3/3 + x**5/10 - 8*x**7/315 + O(x**8) + +def test_fps__inverse(): + f1, f2, f3 = fps(sin(x)), fps(exp(x)), fps(cos(x)) + + raises(ValueError, lambda: f1.inverse(x)) + raises(ValueError, lambda: f1.inverse(x, n=8)) + + assert f2.inverse(x) == 1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + O(x**6) + assert f2.inverse(x, n=8) == \ + 1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + x**6/720 - x**7/5040 + O(x**8) + + assert f3.inverse(x) == 1 + x**2/2 + 5*x**4/24 + O(x**6) + assert f3.inverse(x, n=8) == 1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + O(x**8)

[ { "components": [ { "doc": "", "lines": [ 947, 953 ], "name": "FormalPowerSeries.__init__", "signature": "def __init__(self, *args):", "type": "function" }, { "doc": "self.coeff_bell(n) returns a sequence of Bell polyn...

[ "test_fps__composition" ]

[ "test_rational_algorithm", "test_rational_independent", "test_simpleDE", "test_exp_re", "test_hyper_re", "test_fps", "test_fps_shift", "test_fps__Add_expr", "test_fps__asymptotic", "test_fps__fractional", "test_fps__logarithmic_singularity", "test_fps_symbolic", "test_fps__slow", "test_fps...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [GSoC] Implementation of composition and inversion of formal power series  #### References to other Issues or PRs Fixes Issue #16975 . #### Brief description of what is fixed or changed Composition of two `FormalPowerSeries` objects have been implemented. Presently, it takes in a order `n` term, and prints all the terms in the composed resultant fps upto order. No FormalPowerSeries object is being returned as of now. For `composition`, there exists a closed form expression for the resultant power series, where the resultant coefficient sequence `ak` involves Bell polynomials, as follows -- ![image](https://user-images.githubusercontent.com/28482640/58986902-ffd1ee80-87fb-11e9-95d5-bf4965dd4c1c.png) For `inversion`, there exists a similar `Bell-polynomial` closed form expression. #### Other comments #### Release Notes   * series * Implemented composition and inversion operation of two formal power series in `sympy.series.formal`  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/series/formal.py] (definition of FormalPowerSeries.__init__:) def __init__(self, *args): (definition of FormalPowerSeries.coeff_bell:) def coeff_bell(self, n): """self.coeff_bell(n) returns a sequence of Bell polynomials of the second kind. Note that ``n`` should be a integer. The second kind of Bell polynomials (are sometimes called "partial" Bell polynomials or incomplete Bell polynomials) are defined as .. math:: B_{n,k}(x_1, x_2,\dotsc x_{n-k+1}) = \sum_{j_1+j_2+j_2+\dotsb=k \atop j_1+2j_2+3j_2+\dotsb=n} \frac{n!}{j_1!j_2!\dotsb j_{n-k+1}!} \left(\frac{x_1}{1!} \right)^{j_1} \left(\frac{x_2}{2!} \right)^{j_2} \dotsb \left(\frac{x_{n-k+1}}{(n-k+1)!} \right) ^{j_{n-k+1}}. * ``bell(n, k, (x1, x2, ...))`` gives Bell polynomials of the second kind, `B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1})`. See Also ======== sympy.functions.combinatorial.numbers.bell""" (definition of FormalPowerSeries.compose:) def compose(self, other, x=None, n=6): """Returns the truncated terms of the formal power series of the composed function, up to specified `n`. If `f` and `g` are two formal power series of two different functions, then the coefficient sequence ``ak`` of the composed formal power series `fp` will be as follows. .. math:: \sum\limits_{k=0}^{n} b_k B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1}) Parameters ========== n : Number, optional Specifies the order of the term up to which the polynomial should be truncated. Examples ======== >>> from sympy import fps, sin, exp, bell >>> from sympy.abc import x >>> f1 = fps(exp(x)) >>> f2 = fps(sin(x)) >>> f1.compose(f2, x) 1 + x + x**2/2 - x**4/8 - x**5/15 + O(x**6) >>> f1.compose(f2, x, n=8) 1 + x + x**2/2 - x**4/8 - x**5/15 - x**6/240 + x**7/90 + O(x**8) See Also ======== sympy.functions.combinatorial.numbers.bell References ========== .. [1] Comtet, Louis: Advanced combinatorics; the art of finite and infinite expansions. Reidel, 1974.""" (definition of FormalPowerSeries.inverse:) def inverse(self, x=None, n=6): """Returns the truncated terms of the inverse of the formal power series, up to specified `n`. If `f` and `g` are two formal power series of two different functions, then the coefficient sequence ``ak`` of the composed formal power series `fp` will be as follows. .. math:: \sum\limits_{k=0}^{n} (-1)^{k} x_0^{-k-1} B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1}) Parameters ========== n : Number, optional Specifies the order of the term up to which the polynomial should be truncated. Examples ======== >>> from sympy import fps, exp, cos, bell >>> from sympy.abc import x >>> f1 = fps(exp(x)) >>> f2 = fps(cos(x)) >>> f1.inverse(x) 1 - x + x**2/2 - x**3/6 + x**4/24 - x**5/120 + O(x**6) >>> f2.inverse(x, n=8) 1 + x**2/2 + 5*x**4/24 + 61*x**6/720 + O(x**8) See Also ======== sympy.functions.combinatorial.numbers.bell References ========== .. [1] Comtet, Louis: Advanced combinatorics; the art of finite and infinite expansions. Reidel, 1974.""" [end of new definitions in sympy/series/formal.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-17041

17,041

sympy/sympy

1.5

dec26834d188f14f2647b1687837b1e87d92a8e5

2019-06-17T17:02:44Z

diff --git a/doc/src/modules/codegen.rst b/doc/src/modules/codegen.rst index 0ec801865bb8..6ad67e51df09 100644 --- a/doc/src/modules/codegen.rst +++ b/doc/src/modules/codegen.rst @@ -548,6 +548,9 @@ Classes and functions for rewriting expressions (sympy.codegen.rewriting) .. automodule:: sympy.codegen.rewriting :members: +.. automodule:: sympy.codegen.matrix_nodes + :members: + Tools for simplifying expressions using approximations (sympy.codegen.approximations) ------------------------------------------------------------------------------------- diff --git a/sympy/codegen/matrix_nodes.py b/sympy/codegen/matrix_nodes.py new file mode 100644 index 000000000000..3acc81c25706 --- /dev/null +++ b/sympy/codegen/matrix_nodes.py @@ -0,0 +1,65 @@ +""" +Additional AST nodes for operations on matrices. The nodes in this module +are meant to represent optimization of matrix expressions within codegen's +target languages that cannot be represented by SymPy expressions. + +As an example, we can use :meth:`sympy.codegen.rewriting.optimize` and the +``matin_opt`` optimization provided in :mod:`sympy.codegen.rewriting` to +transform matrix multiplication under certain assumptions: + + >>> from sympy import symbols, MatrixSymbol + >>> n = symbols('n', integer=True) + >>> A = MatrixSymbol('A', n, n) + >>> x = MatrixSymbol('x', n, 1) + >>> expr = A**(-1) * x + >>> from sympy.assumptions import assuming, Q + >>> from sympy.codegen.rewriting import matinv_opt, optimize + >>> with assuming(Q.fullrank(A)): + ... optimize(expr, [matinv_opt]) + MatrixSolve(A, vector=x) +""" + +from .ast import Token +from sympy.matrices import MatrixExpr +from sympy.core.sympify import sympify + + +class MatrixSolve(Token, MatrixExpr): + """Represents an operation to solve a linear matrix equation. + + Parameters + ========== + + matrix : MatrixSymbol + + Matrix representing the coefficients of variables in the linear + equation. This matrix must be square and full-rank (i.e. all columns must + be linearly independent) for the solving operation to be valid. + + vector : MatrixSymbol + + One-column matrix representing the solutions to the equations + represented in ``matrix``. + + Examples + ======== + + >>> from sympy import symbols, MatrixSymbol + >>> from sympy.codegen.matrix_nodes import MatrixSolve + >>> n = symbols('n', integer=True) + >>> A = MatrixSymbol('A', n, n) + >>> x = MatrixSymbol('x', n, 1) + >>> from sympy.printing.pycode import NumPyPrinter + >>> NumPyPrinter().doprint(MatrixSolve(A, x)) + 'numpy.linalg.solve(A, x)' + >>> from sympy.printing import octave_code + >>> octave_code(MatrixSolve(A, x)) + 'A \\\\ x' + + """ + __slots__ = ['matrix', 'vector'] + + _construct_matrix = staticmethod(sympify) + + def __init__(self, matrix, vector): + self.shape = self.vector.shape diff --git a/sympy/codegen/rewriting.py b/sympy/codegen/rewriting.py index 09d45c8ce627..fee8ee35ba79 100644 --- a/sympy/codegen/rewriting.py +++ b/sympy/codegen/rewriting.py @@ -33,10 +33,13 @@ from __future__ import (absolute_import, division, print_function) from itertools import chain from sympy import log, exp, Max, Min, Wild, expand_log, Dummy +from sympy.assumptions import Q, ask from sympy.codegen.cfunctions import log1p, log2, exp2, expm1 +from sympy.codegen.matrix_nodes import MatrixSolve from sympy.core.expr import UnevaluatedExpr from sympy.core.mul import Mul from sympy.core.power import Pow +from sympy.matrices.expressions.matexpr import MatrixSymbol from sympy.utilities.iterables import sift @@ -228,5 +231,26 @@ def create_expand_pow_optimization(limit): 1/UnevaluatedExpr(Mul(*([p.base]*-p.exp), evaluate=False)) )) +# Optimization procedures for turning A**(-1) * x into MatrixSolve(A, x) +def _matinv_predicate(expr): + # TODO: We should be able to support more than 2 elements + if expr.is_MatMul and len(expr.args) == 2: + left, right = expr.args + if left.is_Inverse and right.shape[1] == 1: + inv_arg = left.arg + if isinstance(inv_arg, MatrixSymbol): + return bool(ask(Q.fullrank(left.arg))) + + return False + +def _matinv_transform(expr): + left, right = expr.args + inv_arg = left.arg + return MatrixSolve(inv_arg, right) + + +matinv_opt = ReplaceOptim(_matinv_predicate, _matinv_transform) + + # Collections of optimizations: optims_c99 = (expm1_opt, log1p_opt, exp2_opt, log2_opt, log2const_opt) diff --git a/sympy/printing/octave.py b/sympy/printing/octave.py index ac63d5ebbff4..95504f568c43 100644 --- a/sympy/printing/octave.py +++ b/sympy/printing/octave.py @@ -233,6 +233,10 @@ def _print_MatPow(self, expr): return '%s^%s' % (self.parenthesize(expr.base, PREC), self.parenthesize(expr.exp, PREC)) + def _print_MatrixSolve(self, expr): + PREC = precedence(expr) + return "%s \\ %s" % (self.parenthesize(expr.matrix, PREC), + self.parenthesize(expr.vector, PREC)) def _print_Pi(self, expr): return 'pi' diff --git a/sympy/printing/precedence.py b/sympy/printing/precedence.py index 063c1cf626d7..7eb4eac6dade 100644 --- a/sympy/printing/precedence.py +++ b/sympy/printing/precedence.py @@ -40,6 +40,7 @@ "NegativeInfinity": PRECEDENCE["Add"], "MatAdd": PRECEDENCE["Add"], "MatPow": PRECEDENCE["Pow"], + "MatrixSolve": PRECEDENCE["Mul"], "TensAdd": PRECEDENCE["Add"], # As soon as `TensMul` is a subclass of `Mul`, remove this: "TensMul": PRECEDENCE["Mul"], diff --git a/sympy/printing/pycode.py b/sympy/printing/pycode.py index e9ecd9e32db4..d41802eb9588 100644 --- a/sympy/printing/pycode.py +++ b/sympy/printing/pycode.py @@ -626,6 +626,11 @@ def _print_DotProduct(self, expr): self._print(arg1), self._print(arg2)) + def _print_MatrixSolve(self, expr): + return "%s(%s, %s)" % (self._module_format('numpy.linalg.solve'), + self._print(expr.matrix), + self._print(expr.vector)) + def _print_Piecewise(self, expr): "Piecewise function printer" exprs = '[{0}]'.format(','.join(self._print(arg.expr) for arg in expr.args))

diff --git a/sympy/codegen/tests/test_rewriting.py b/sympy/codegen/tests/test_rewriting.py index 93da5092ab86..da42a08819d9 100644 --- a/sympy/codegen/tests/test_rewriting.py +++ b/sympy/codegen/tests/test_rewriting.py @@ -1,11 +1,13 @@ from __future__ import (absolute_import, print_function) -from sympy import log, exp, Symbol, Pow, sin +from sympy import log, exp, Symbol, Pow, sin, MatrixSymbol +from sympy.assumptions import assuming, Q from sympy.printing.ccode import ccode +from sympy.codegen.matrix_nodes import MatrixSolve from sympy.codegen.cfunctions import log2, exp2, expm1, log1p from sympy.codegen.rewriting import ( optimize, log2_opt, exp2_opt, expm1_opt, log1p_opt, optims_c99, - create_expand_pow_optimization + create_expand_pow_optimization, matinv_opt ) from sympy.utilities.pytest import XFAIL @@ -172,3 +174,13 @@ def test_create_expand_pow_optimization(): assert cc(x**4 - x**2) == '-x*x + x*x*x*x' i = Symbol('i', integer=True) assert cc(x**i - x**2) == 'pow(x, i) - x*x' + + +def test_matsolve(): + n = Symbol('n', integer=True) + A = MatrixSymbol('A', n, n) + x = MatrixSymbol('x', n, 1) + + with assuming(Q.fullrank(A)): + assert optimize(A**(-1) * x, [matinv_opt]) == MatrixSolve(A, x) + assert optimize(A**(-1) * x + x, [matinv_opt]) == MatrixSolve(A, x) + x diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index a8f7f03755c2..1a03df681874 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -4503,6 +4503,14 @@ def test_sympy__codegen__fnodes__literal_dp(): assert _test_args(literal_dp(1)) +def test_sympy__codegen__matrix_nodes__MatrixSolve(): + from sympy.matrices import MatrixSymbol + from sympy.codegen.matrix_nodes import MatrixSolve + A = MatrixSymbol('A', 3, 3) + v = MatrixSymbol('x', 3, 1) + assert _test_args(MatrixSolve(A, v)) + + def test_sympy__vector__coordsysrect__CoordSys3D(): from sympy.vector.coordsysrect import CoordSys3D assert _test_args(CoordSys3D('C')) diff --git a/sympy/printing/tests/test_numpy.py b/sympy/printing/tests/test_numpy.py index 13627064ecb4..bf6d347b0195 100644 --- a/sympy/printing/tests/test_numpy.py +++ b/sympy/printing/tests/test_numpy.py @@ -4,6 +4,7 @@ ) from sympy import eye from sympy.abc import x, i, j, a, b, c, d +from sympy.codegen.matrix_nodes import MatrixSolve from sympy.codegen.cfunctions import log1p, expm1, hypot, log10, exp2, log2, Cbrt, Sqrt from sympy.codegen.array_utils import (CodegenArrayContraction, CodegenArrayTensorProduct, CodegenArrayDiagonal, @@ -226,6 +227,28 @@ def test_sqrt(): skip("NumPy not installed") assert abs(lambdify((a,), sqrt(a), 'numpy')(4) - 2) < 1e-16 + +def test_matsolve(): + if not np: + skip("NumPy not installed") + + M = MatrixSymbol("M", 3, 3) + x = MatrixSymbol("x", 3, 1) + + expr = M**(-1) * x + x + matsolve_expr = MatrixSolve(M, x) + x + + f = lambdify((M, x), expr) + f_matsolve = lambdify((M, x), matsolve_expr) + + m0 = np.array([[1, 2, 3], [3, 2, 5], [5, 6, 7]]) + assert np.linalg.matrix_rank(m0) == 3 + + x0 = np.array([3, 4, 5]) + + assert np.allclose(f_matsolve(m0, x0), f(m0, x0)) + + def test_issue_15601(): if not np: skip("Numpy not installed") diff --git a/sympy/printing/tests/test_octave.py b/sympy/printing/tests/test_octave.py index 0ff33b1b3616..409354e8d65e 100644 --- a/sympy/printing/tests/test_octave.py +++ b/sympy/printing/tests/test_octave.py @@ -1,6 +1,7 @@ from sympy.core import (S, pi, oo, symbols, Function, Rational, Integer, Tuple, Symbol) from sympy.core import EulerGamma, GoldenRatio, Catalan, Lambda, Mul, Pow +from sympy.codegen.matrix_nodes import MatrixSolve from sympy.functions import (arg, atan2, bernoulli, beta, ceiling, chebyshevu, chebyshevt, conjugate, DiracDelta, exp, expint, factorial, floor, harmonic, Heaviside, im, @@ -251,6 +252,12 @@ def test_MatrixSymbol(): assert mcode(A**(S.Half)) == "A^(1/2)" +def test_MatrixSolve(): + n = Symbol('n', integer=True) + A = MatrixSymbol('A', n, n) + x = MatrixSymbol('x', n, 1) + assert mcode(MatrixSolve(A, x)) == "A \\ x" + def test_special_matrices(): assert mcode(6*Identity(3)) == "6*eye(3)" diff --git a/sympy/printing/tests/test_pycode.py b/sympy/printing/tests/test_pycode.py index fbb3607b4286..8e20f3469a15 100644 --- a/sympy/printing/tests/test_pycode.py +++ b/sympy/printing/tests/test_pycode.py @@ -3,6 +3,7 @@ from sympy.codegen import Assignment from sympy.codegen.ast import none +from sympy.codegen.matrix_nodes import MatrixSolve from sympy.core import Expr, Mod, symbols, Eq, Le, Gt, zoo, oo, Rational from sympy.core.singleton import S from sympy.core.numbers import pi @@ -72,6 +73,10 @@ def test_NumPyPrinter(): assert p.doprint(A**(-1)) == "numpy.linalg.inv(A)" assert p.doprint(A**5) == "numpy.linalg.matrix_power(A, 5)" + u = MatrixSymbol('x', 2, 1) + v = MatrixSymbol('y', 2, 1) + assert p.doprint(MatrixSolve(A, u)) == 'numpy.linalg.solve(A, x)' + assert p.doprint(MatrixSolve(A, u) + v) == 'numpy.linalg.solve(A, x) + y' # Workaround for numpy negative integer power errors assert p.doprint(x**-1) == 'x**(-1.0)' assert p.doprint(x**-2) == 'x**(-2.0)'

diff --git a/doc/src/modules/codegen.rst b/doc/src/modules/codegen.rst index 0ec801865bb8..6ad67e51df09 100644 --- a/doc/src/modules/codegen.rst +++ b/doc/src/modules/codegen.rst @@ -548,6 +548,9 @@ Classes and functions for rewriting expressions (sympy.codegen.rewriting) .. automodule:: sympy.codegen.rewriting :members: +.. automodule:: sympy.codegen.matrix_nodes + :members: + Tools for simplifying expressions using approximations (sympy.codegen.approximations) -------------------------------------------------------------------------------------

[ { "components": [ { "doc": "Represents an operation to solve a linear matrix equation.\n\nParameters\n==========\n\nmatrix : MatrixSymbol\n\n Matrix representing the coefficients of variables in the linear\n equation. This matrix must be square and full-rank (i.e. all columns must\n be linearly...

[ "test_log2_opt", "test_exp2_opt", "test_expm1_opt", "test_log1p_opt", "test_optims_c99", "test_create_expand_pow_optimization", "test_sympy__codegen__matrix_nodes__MatrixSolve", "test_numpy_piecewise_regression", "test_Integer", "test_Rational", "test_Function", "test_Function_change_name", ...

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add optimization of numpy code involving matrix inverses  #### Brief description of what is fixed or changed Adds an `optimization` option to the code printer base class that executes any `codegen.rewriting` optimizations the printer object might have. Also adds an optimization to the numpy printer that uses the assumption system to rewrite the multiplication of a matrix and a vector as the faster `np.linalg.solve` when appropriate. For example: ```python3 >>> from sympy.assumptions import assuming, Q >>> from sympy.matrices import MatrixSymbol >>> from sympy.printing.pycode import NumPyPrinter >>> A = MatrixSymbol('A', 2, 2) >>> x = MatrixSymbol('x', 2, 1) >>> p = NumPyPrinter(settings={'optimize' : True}) >>> print(p.doprint(A**(-1) * x)) (numpy.linalg.inv(A)).dot(x) >>> with assuming(Q.fullrank(A)): ... p.doprint(A**(-1) * x) numpy.linalg.solve(A, x) ``` #### Other comments This PR is mostly meant as an exploration of how (and whether) the `codegen.rewriting` module is enough for generating optimizations. I'd appreciate comments and suggestions about this approach. #### Release Notes  * printing * Add support for optimizations to numpy printer. * The numpy and octave printers print matrix expressions like `A**-1*x` using a `solve`.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/codegen/matrix_nodes.py] (definition of MatrixSolve:) class MatrixSolve(Token, MatrixExpr): """Represents an operation to solve a linear matrix equation. Parameters ========== matrix : MatrixSymbol Matrix representing the coefficients of variables in the linear equation. This matrix must be square and full-rank (i.e. all columns must be linearly independent) for the solving operation to be valid. vector : MatrixSymbol One-column matrix representing the solutions to the equations represented in ``matrix``. Examples ======== >>> from sympy import symbols, MatrixSymbol >>> from sympy.codegen.matrix_nodes import MatrixSolve >>> n = symbols('n', integer=True) >>> A = MatrixSymbol('A', n, n) >>> x = MatrixSymbol('x', n, 1) >>> from sympy.printing.pycode import NumPyPrinter >>> NumPyPrinter().doprint(MatrixSolve(A, x)) 'numpy.linalg.solve(A, x)' >>> from sympy.printing import octave_code >>> octave_code(MatrixSolve(A, x)) 'A \\ x'""" (definition of MatrixSolve.__init__:) def __init__(self, matrix, vector): [end of new definitions in sympy/codegen/matrix_nodes.py] [start of new definitions in sympy/codegen/rewriting.py] (definition of _matinv_predicate:) def _matinv_predicate(expr): (definition of _matinv_transform:) def _matinv_transform(expr): [end of new definitions in sympy/codegen/rewriting.py] [start of new definitions in sympy/printing/octave.py] (definition of OctaveCodePrinter._print_MatrixSolve:) def _print_MatrixSolve(self, expr): [end of new definitions in sympy/printing/octave.py] [start of new definitions in sympy/printing/pycode.py] (definition of NumPyPrinter._print_MatrixSolve:) def _print_MatrixSolve(self, expr): [end of new definitions in sympy/printing/pycode.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

joblib__joblib-894

894

joblib/joblib

null

c2087dbdeec9824c45822670395a8a0c45be2211

2019-06-14T18:33:04Z

diff --git a/CHANGES.rst b/CHANGES.rst index 5bf9c956e..e191018d6 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -4,11 +4,14 @@ Latest changes In development -------------- +- Allow caching co-routines with `Memory.cache`. + https://github.com/joblib/joblib/pull/894 + - Try to cast ``n_jobs`` to int in parallel and raise an error if it fails. This means that ``n_jobs=2.3`` will now result in ``effective_n_jobs=2`` instead of failing. https://github.com/joblib/joblib/pull/1539 - + - Ensure that errors in the task generator given to Parallel's call are raised in the results consumming thread. https://github.com/joblib/joblib/pull/1491 diff --git a/continuous_integration/install.sh b/continuous_integration/install.sh index c6fed2883..9668b7474 100755 --- a/continuous_integration/install.sh +++ b/continuous_integration/install.sh @@ -34,7 +34,7 @@ else fi # Install pytest timeout to fasten failure in deadlocking tests -PIP_INSTALL_PACKAGES="pytest-timeout threadpoolctl" +PIP_INSTALL_PACKAGES="pytest-timeout pytest-asyncio==0.21.1 threadpoolctl" if [ -n "$NUMPY_VERSION" ]; then # We want to ensure no memory copies are performed only when numpy is diff --git a/joblib/_store_backends.py b/joblib/_store_backends.py index ce9146098..68e207c17 100644 --- a/joblib/_store_backends.py +++ b/joblib/_store_backends.py @@ -7,6 +7,7 @@ import datetime import json import shutil +import time import warnings import collections import operator @@ -15,6 +16,7 @@ from .backports import concurrency_safe_rename from .disk import mkdirp, memstr_to_bytes, rm_subdirs +from .logger import format_time from . import numpy_pickle CacheItemInfo = collections.namedtuple('CacheItemInfo', @@ -151,12 +153,19 @@ class StoreBackendMixin(object): file-like object. """ - def load_item(self, path, verbose=1, msg=None): - """Load an item from the store given its path as a list of - strings.""" - full_path = os.path.join(self.location, *path) + def load_item(self, call_id, verbose=1, timestamp=None, metadata=None): + """Load an item from the store given its id as a list of str.""" + full_path = os.path.join(self.location, *call_id) if verbose > 1: + ts_string = ('{: <16}'.format(format_time(time.time() - timestamp)) + if timestamp is not None else '') + signature = os.path.basename(call_id[0]) + if metadata is not None and 'input_args' in metadata: + kwargs = ', '.join('{}={}'.format(*item) + for item in metadata['input_args'].items()) + signature += '({})'.format(kwargs) + msg = '[Memory]{}: Loading {}'.format(ts_string, signature) if verbose < 10: print('{0}...'.format(msg)) else: @@ -178,11 +187,10 @@ def load_item(self, path, verbose=1, msg=None): item = numpy_pickle.load(filename, mmap_mode=mmap_mode) return item - def dump_item(self, path, item, verbose=1): - """Dump an item in the store at the path given as a list of - strings.""" + def dump_item(self, call_id, item, verbose=1): + """Dump an item in the store at the id given as a list of str.""" try: - item_path = os.path.join(self.location, *path) + item_path = os.path.join(self.location, *call_id) if not self._item_exists(item_path): self.create_location(item_path) filename = os.path.join(item_path, 'output.pkl') @@ -210,39 +218,37 @@ def write_func(to_write, dest_filename): CacheWarning ) - def clear_item(self, path): - """Clear the item at the path, given as a list of strings.""" - item_path = os.path.join(self.location, *path) + def clear_item(self, call_id): + """Clear the item at the id, given as a list of str.""" + item_path = os.path.join(self.location, *call_id) if self._item_exists(item_path): self.clear_location(item_path) - def contains_item(self, path): - """Check if there is an item at the path, given as a list of - strings""" - item_path = os.path.join(self.location, *path) + def contains_item(self, call_id): + """Check if there is an item at the id, given as a list of str.""" + item_path = os.path.join(self.location, *call_id) filename = os.path.join(item_path, 'output.pkl') return self._item_exists(filename) - def get_item_info(self, path): + def get_item_info(self, call_id): """Return information about item.""" - return {'location': os.path.join(self.location, - *path)} + return {'location': os.path.join(self.location, *call_id)} - def get_metadata(self, path): + def get_metadata(self, call_id): """Return actual metadata of an item.""" try: - item_path = os.path.join(self.location, *path) + item_path = os.path.join(self.location, *call_id) filename = os.path.join(item_path, 'metadata.json') with self._open_item(filename, 'rb') as f: return json.loads(f.read().decode('utf-8')) except: # noqa: E722 return {} - def store_metadata(self, path, metadata): + def store_metadata(self, call_id, metadata): """Store metadata of a computation.""" try: - item_path = os.path.join(self.location, *path) + item_path = os.path.join(self.location, *call_id) self.create_location(item_path) filename = os.path.join(item_path, 'metadata.json') @@ -254,20 +260,20 @@ def write_func(to_write, dest_filename): except: # noqa: E722 pass - def contains_path(self, path): + def contains_path(self, call_id): """Check cached function is available in store.""" - func_path = os.path.join(self.location, *path) + func_path = os.path.join(self.location, *call_id) return self.object_exists(func_path) - def clear_path(self, path): + def clear_path(self, call_id): """Clear all items with a common path in the store.""" - func_path = os.path.join(self.location, *path) + func_path = os.path.join(self.location, *call_id) if self._item_exists(func_path): self.clear_location(func_path) - def store_cached_func_code(self, path, func_code=None): + def store_cached_func_code(self, call_id, func_code=None): """Store the code of the cached function.""" - func_path = os.path.join(self.location, *path) + func_path = os.path.join(self.location, *call_id) if not self._item_exists(func_path): self.create_location(func_path) @@ -276,19 +282,18 @@ def store_cached_func_code(self, path, func_code=None): with self._open_item(filename, 'wb') as f: f.write(func_code.encode('utf-8')) - def get_cached_func_code(self, path): + def get_cached_func_code(self, call_id): """Store the code of the cached function.""" - path += ['func_code.py', ] - filename = os.path.join(self.location, *path) + filename = os.path.join(self.location, *call_id, 'func_code.py') try: with self._open_item(filename, 'rb') as f: return f.read().decode('utf-8') except: # noqa: E722 raise - def get_cached_func_info(self, path): + def get_cached_func_info(self, call_id): """Return information related to the cached function if it exists.""" - return {'location': os.path.join(self.location, *path)} + return {'location': os.path.join(self.location, *call_id)} def clear(self): """Clear the whole store content.""" diff --git a/joblib/memory.py b/joblib/memory.py index 8171d24cb..6f87f8039 100644 --- a/joblib/memory.py +++ b/joblib/memory.py @@ -9,32 +9,28 @@ # License: BSD Style, 3 clauses. -from __future__ import with_statement +import asyncio +import datetime +import functools +import inspect import logging import os -from textwrap import dedent -import time import pathlib import pydoc import re -import functools +import textwrap +import time +import tokenize import traceback import warnings -import inspect import weakref -from datetime import timedelta - -from tokenize import open as open_py_source -# Local imports from . import hashing -from .func_inspect import get_func_code, get_func_name, filter_args -from .func_inspect import format_call -from .func_inspect import format_signature -from .logger import Logger, format_time, pformat -from ._store_backends import StoreBackendBase, FileSystemStoreBackend from ._store_backends import CacheWarning # noqa - +from ._store_backends import FileSystemStoreBackend, StoreBackendBase +from .func_inspect import (filter_args, format_call, format_signature, + get_func_code, get_func_name) +from .logger import Logger, format_time, pformat FIRST_LINE_TEXT = "# first line:" @@ -141,45 +137,11 @@ def _store_backend_factory(backend, location, verbose=0, backend_options=None): return None -def _get_func_fullname(func): - """Compute the part of part associated with a function.""" - modules, funcname = get_func_name(func) - modules.append(funcname) - return os.path.join(*modules) - - def _build_func_identifier(func): """Build a roughly unique identifier for the cached function.""" - parts = [] - if isinstance(func, str): - parts.append(func) - else: - parts.append(_get_func_fullname(func)) - + modules, funcname = get_func_name(func) # We reuse historical fs-like way of building a function identifier - return os.path.join(*parts) - - -def _format_load_msg(func_id, args_id, timestamp=None, metadata=None): - """ Helper function to format the message when loading the results. - """ - signature = "" - try: - if metadata is not None: - args = ", ".join(['%s=%s' % (name, value) - for name, value - in metadata['input_args'].items()]) - signature = "%s(%s)" % (os.path.basename(func_id), args) - else: - signature = os.path.basename(func_id) - except KeyError: - pass - - if timestamp is not None: - ts_string = "{0: <16}".format(format_time(time.time() - timestamp)) - else: - ts_string = "" - return '[Memory]{0}: Loading {1}'.format(ts_string, str(signature)) + return os.path.join(*modules, funcname) # An in-memory store to avoid looking at the disk-based function @@ -220,15 +182,10 @@ class MemorizedResult(Logger): timestamp, metadata: string for internal use only. """ - def __init__(self, location, func, args_id, backend='local', - mmap_mode=None, verbose=0, timestamp=None, metadata=None): + def __init__(self, location, call_id, backend='local', mmap_mode=None, + verbose=0, timestamp=None, metadata=None): Logger.__init__(self) - self.func_id = _build_func_identifier(func) - if isinstance(func, str): - self.func = func - else: - self.func = self.func_id - self.args_id = args_id + self._call_id = call_id self.store_backend = _store_backend_factory(backend, location, verbose=verbose) self.mmap_mode = mmap_mode @@ -236,13 +193,24 @@ def __init__(self, location, func, args_id, backend='local', if metadata is not None: self.metadata = metadata else: - self.metadata = self.store_backend.get_metadata( - [self.func_id, self.args_id]) + self.metadata = self.store_backend.get_metadata(self._call_id) self.duration = self.metadata.get('duration', None) self.verbose = verbose self.timestamp = timestamp + @property + def func(self): + return self.func_id + + @property + def func_id(self): + return self._call_id[0] + + @property + def args_id(self): + return self._call_id[1] + @property def argument_hash(self): warnings.warn( @@ -254,38 +222,29 @@ def argument_hash(self): def get(self): """Read value from cache and return it.""" - if self.verbose: - msg = _format_load_msg(self.func_id, self.args_id, - timestamp=self.timestamp, - metadata=self.metadata) - else: - msg = None - try: return self.store_backend.load_item( - [self.func_id, self.args_id], msg=msg, verbose=self.verbose) + self._call_id, + timestamp=self.timestamp, + metadata=self.metadata, + verbose=self.verbose + ) except ValueError as exc: new_exc = KeyError( "Error while trying to load a MemorizedResult's value. " "It seems that this folder is corrupted : {}".format( - os.path.join( - self.store_backend.location, self.func_id, - self.args_id) - )) + os.path.join(self.store_backend.location, *self._call_id))) raise new_exc from exc def clear(self): """Clear value from cache""" - self.store_backend.clear_item([self.func_id, self.args_id]) + self.store_backend.clear_item(self._call_id) def __repr__(self): - return ('{class_name}(location="{location}", func="{func}", ' - 'args_id="{args_id}")' - .format(class_name=self.__class__.__name__, - location=self.store_backend.location, - func=self.func, - args_id=self.args_id - )) + return '{}(location="{}", func="{}", args_id="{}")'.format( + self.__class__.__name__, self.store_backend.location, + *self._call_id + ) def __getstate__(self): state = self.__dict__.copy() @@ -369,6 +328,14 @@ def check_call_in_cache(self, *args, **kwargs): return False +############################################################################### +# class `AsyncNotMemorizedFunc` +############################################################################### +class AsyncNotMemorizedFunc(NotMemorizedFunc): + async def call_and_shelve(self, *args, **kwargs): + return NotMemorizedResult(await self.func(*args, **kwargs)) + + ############################################################################### # class `MemorizedFunc` ############################################################################### @@ -429,10 +396,8 @@ def __init__(self, func, location, backend='local', ignore=None, self.compress = compress self.func = func self.cache_validation_callback = cache_validation_callback - - if ignore is None: - ignore = [] - self.ignore = ignore + self.func_id = _build_func_identifier(func) + self.ignore = ignore if ignore is not None else [] self._verbose = verbose # retrieve store object from backend type and location. @@ -444,17 +409,13 @@ def __init__(self, func, location, backend='local', ignore=None, ) if self.store_backend is not None: # Create func directory on demand. - self.store_backend.store_cached_func_code([ - _build_func_identifier(self.func) - ]) + self.store_backend.store_cached_func_code([self.func_id]) - if timestamp is None: - timestamp = time.time() - self.timestamp = timestamp + self.timestamp = timestamp if timestamp is not None else time.time() try: functools.update_wrapper(self, func) except Exception: - " Objects like ufunc don't like that " + pass # Objects like ufunc don't like that if inspect.isfunction(func): doc = pydoc.TextDoc().document(func) # Remove blank line @@ -469,7 +430,7 @@ def __init__(self, func, location, backend='local', ignore=None, self._func_code_info = None self._func_code_id = None - def _is_in_cache_and_valid(self, path): + def _is_in_cache_and_valid(self, call_id): """Check if the function call is cached and valid for given arguments. - Compare the function code with the one from the cached function, @@ -485,22 +446,23 @@ def _is_in_cache_and_valid(self, path): return False # Check if this specific call is in the cache - if not self.store_backend.contains_item(path): + if not self.store_backend.contains_item(call_id): return False # Call the user defined cache validation callback - metadata = self.store_backend.get_metadata(path) + metadata = self.store_backend.get_metadata(call_id) if (self.cache_validation_callback is not None and not self.cache_validation_callback(metadata)): - self.store_backend.clear_item(path) + self.store_backend.clear_item(call_id) return False return True - def _cached_call(self, args, kwargs, shelving=False): + def _cached_call(self, args, kwargs, shelving): """Call wrapped function and cache result, or read cache if available. - This function returns the wrapped function output and some metadata. + This function returns the wrapped function output or a reference to + the cached result. Arguments: ---------- @@ -514,35 +476,22 @@ def _cached_call(self, args, kwargs, shelving=False): Returns ------- - output: value or tuple or None - Output of the wrapped function. - If shelving is True and the call has been already cached, - output is None. - - argument_hash: string - Hash of function arguments. - - metadata: dict - Some metadata about wrapped function call (see _persist_input()). + Output of the wrapped function if shelving is false, or a + MemorizedResult reference to the value if shelving is true. """ - func_id, args_id = self._get_output_identifiers(*args, **kwargs) - metadata = None - msg = None - - # Whether or not the memorized function must be called - must_call = False + args_id = self._get_args_id(*args, **kwargs) + call_id = (self.func_id, args_id) + _, func_name = get_func_name(self.func) + func_info = self.store_backend.get_cached_func_info([self.func_id]) + location = func_info['location'] if self._verbose >= 20: logging.basicConfig(level=logging.INFO) - _, name = get_func_name(self.func) - location = self.store_backend.get_cached_func_info([func_id])[ - 'location'] _, signature = format_signature(self.func, *args, **kwargs) - self.info( - dedent( + textwrap.dedent( f""" - Querying {name} with signature + Querying {func_name} with signature {signature}. (argument hash {args_id}) @@ -555,58 +504,30 @@ def _cached_call(self, args, kwargs, shelving=False): # Compare the function code with the previous to see if the # function code has changed and check if the results are present in # the cache. - if self._is_in_cache_and_valid([func_id, args_id]): - try: - t0 = time.time() - if self._verbose: - msg = _format_load_msg(func_id, args_id, - timestamp=self.timestamp, - metadata=metadata) - - if not shelving: - # When shelving, we do not need to load the output - out = self.store_backend.load_item( - [func_id, args_id], - msg=msg, - verbose=self._verbose) - else: - out = None + if self._is_in_cache_and_valid(call_id): + if shelving: + return self._get_memorized_result(call_id) + try: + start_time = time.time() + output = self._load_item(call_id) if self._verbose > 4: - t = time.time() - t0 - _, name = get_func_name(self.func) - msg = '%s cache loaded - %s' % (name, format_time(t)) - print(max(0, (80 - len(msg))) * '_' + msg) + self._print_duration(time.time() - start_time, + context='cache loaded ') + return output except Exception: # XXX: Should use an exception logger _, signature = format_signature(self.func, *args, **kwargs) self.warn('Exception while loading results for ' '{}\n {}'.format(signature, traceback.format_exc())) - must_call = True - else: - if self._verbose > 10: - _, name = get_func_name(self.func) - self.warn('Computing func {0}, argument hash {1} ' - 'in location {2}' - .format(name, args_id, - self.store_backend. - get_cached_func_info([func_id])['location'])) - must_call = True - - if must_call: - out, metadata = self.call(*args, **kwargs) - if self.mmap_mode is not None: - # Memmap the output at the first call to be consistent with - # later calls - if self._verbose: - msg = _format_load_msg(func_id, args_id, - timestamp=self.timestamp, - metadata=metadata) - out = self.store_backend.load_item([func_id, args_id], msg=msg, - verbose=self._verbose) - - return (out, args_id, metadata) + if self._verbose > 10: + self.warn( + f"Computing func {func_name}, argument hash {args_id} " + f"in location {location}" + ) + + return self._call(call_id, args, kwargs, shelving) @property def func_code_info(self): @@ -646,13 +567,10 @@ def call_and_shelve(self, *args, **kwargs): class "NotMemorizedResult" is used when there is no cache activated (e.g. location=None in Memory). """ - _, args_id, metadata = self._cached_call(args, kwargs, shelving=True) - return MemorizedResult(self.store_backend, self.func, args_id, - metadata=metadata, verbose=self._verbose - 1, - timestamp=self.timestamp) + return self._cached_call(args, kwargs, shelving=True) def __call__(self, *args, **kwargs): - return self._cached_call(args, kwargs)[0] + return self._cached_call(args, kwargs, shelving=False) def __getstate__(self): # Make sure self.func's source is introspected prior to being pickled - @@ -682,22 +600,17 @@ def check_call_in_cache(self, *args, **kwargs): Whether or not the result of the function has been cached for the input arguments that have been passed. """ - func_id, args_id = self._get_output_identifiers(*args, **kwargs) - return self.store_backend.contains_item((func_id, args_id)) + call_id = (self.func_id, self._get_args_id(*args, **kwargs)) + return self.store_backend.contains_item(call_id) # ------------------------------------------------------------------------ # Private interface # ------------------------------------------------------------------------ - def _get_argument_hash(self, *args, **kwargs): + def _get_args_id(self, *args, **kwargs): + """Return the input parameter hash of a result.""" return hashing.hash(filter_args(self.func, self.ignore, args, kwargs), - coerce_mmap=(self.mmap_mode is not None)) - - def _get_output_identifiers(self, *args, **kwargs): - """Return the func identifier and input parameter hash of a result.""" - func_id = _build_func_identifier(self.func) - argument_hash = self._get_argument_hash(*args, **kwargs) - return func_id, argument_hash + coerce_mmap=self.mmap_mode is not None) def _hash_func(self): """Hash a function to key the online cache""" @@ -712,12 +625,10 @@ def _write_func_code(self, func_code, first_line): # sometimes have several functions named the same way in a # file. This is bad practice, but joblib should be robust to bad # practice. - func_id = _build_func_identifier(self.func) func_code = u'%s %i\n%s' % (FIRST_LINE_TEXT, first_line, func_code) - self.store_backend.store_cached_func_code([func_id], func_code) + self.store_backend.store_cached_func_code([self.func_id], func_code) # Also store in the in-memory store of function hashes - is_named_callable = False is_named_callable = (hasattr(self.func, '__name__') and self.func.__name__ != '<lambda>') if is_named_callable: @@ -755,12 +666,9 @@ def _check_previous_func_code(self, stacklevel=2): # changing code and collision. We cannot inspect.getsource # because it is not reliable when using IPython's magic "%run". func_code, source_file, first_line = self.func_code_info - func_id = _build_func_identifier(self.func) - try: - old_func_code, old_first_line =\ - extract_first_line( - self.store_backend.get_cached_func_code([func_id])) + old_func_code, old_first_line = extract_first_line( + self.store_backend.get_cached_func_code([self.func_id])) except (IOError, OSError): # some backend can also raise OSError self._write_func_code(func_code, first_line) return False @@ -789,11 +697,10 @@ def _check_previous_func_code(self, stacklevel=2): # file has not changed, but the name we have is pointing to a new # code block. if not old_first_line == first_line and source_file is not None: - possible_collision = False if os.path.exists(source_file): _, func_name = get_func_name(self.func, resolv_alias=False) num_lines = len(func_code.split('\n')) - with open_py_source(source_file) as f: + with tokenize.open(source_file) as f: on_disk_func_code = f.readlines()[ old_first_line - 1:old_first_line - 1 + num_lines - 1] on_disk_func_code = ''.join(on_disk_func_code) @@ -814,14 +721,13 @@ def _check_previous_func_code(self, stacklevel=2): if self._verbose > 10: _, func_name = get_func_name(self.func, resolv_alias=False) self.warn("Function {0} (identified by {1}) has changed" - ".".format(func_name, func_id)) + ".".format(func_name, self.func_id)) self.clear(warn=True) return False def clear(self, warn=True): """Empty the function's cache.""" - func_id = _build_func_identifier(self.func) - + func_id = self.func_id if self._verbose > 0 and warn: self.warn("Clearing function cache identified by %s" % func_id) self.store_backend.clear_path([func_id, ]) @@ -846,27 +752,38 @@ def call(self, *args, **kwargs): ------- output : object The output of the function call. - metadata : dict - The metadata associated with the call. """ + call_id = (self.func_id, self._get_args_id(*args, **kwargs)) + return self._call(call_id, args, kwargs) + + def _call(self, call_id, args, kwargs, shelving=False): + self._before_call(args, kwargs) start_time = time.time() - func_id, args_id = self._get_output_identifiers(*args, **kwargs) + output = self.func(*args, **kwargs) + return self._after_call(call_id, args, kwargs, shelving, + output, start_time) + + def _before_call(self, args, kwargs): if self._verbose > 0: print(format_call(self.func, args, kwargs)) - output = self.func(*args, **kwargs) - self.store_backend.dump_item( - [func_id, args_id], output, verbose=self._verbose) + def _after_call(self, call_id, args, kwargs, shelving, output, start_time): + self.store_backend.dump_item(call_id, output, verbose=self._verbose) duration = time.time() - start_time - metadata = self._persist_input(duration, args, kwargs) - if self._verbose > 0: - _, name = get_func_name(self.func) - msg = '%s - %s' % (name, format_time(duration)) - print(max(0, (80 - len(msg))) * '_' + msg) - return output, metadata - - def _persist_input(self, duration, args, kwargs, this_duration_limit=0.5): + self._print_duration(duration) + metadata = self._persist_input(duration, call_id, args, kwargs) + if shelving: + return self._get_memorized_result(call_id, metadata) + + if self.mmap_mode is not None: + # Memmap the output at the first call to be consistent with + # later calls + output = self._load_item(call_id, metadata) + return output + + def _persist_input(self, duration, call_id, args, kwargs, + this_duration_limit=0.5): """ Save a small summary of the call using json format in the output directory. @@ -894,8 +811,7 @@ def _persist_input(self, duration, args, kwargs, this_duration_limit=0.5): "duration": duration, "input_args": input_repr, "time": start_time, } - func_id, args_id = self._get_output_identifiers(*args, **kwargs) - self.store_backend.store_metadata([func_id, args_id], metadata) + self.store_backend.store_metadata(call_id, metadata) this_duration = time.time() - start_time if this_duration > this_duration_limit: @@ -914,6 +830,21 @@ def _persist_input(self, duration, args, kwargs, this_duration_limit=0.5): % this_duration, stacklevel=5) return metadata + def _get_memorized_result(self, call_id, metadata=None): + return MemorizedResult(self.store_backend, call_id, + metadata=metadata, timestamp=self.timestamp, + verbose=self._verbose - 1) + + def _load_item(self, call_id, metadata=None): + return self.store_backend.load_item(call_id, metadata=metadata, + timestamp=self.timestamp, + verbose=self._verbose) + + def _print_duration(self, duration, context=''): + _, name = get_func_name(self.func) + msg = f"{name} {context}- {format_time(duration)}" + print(max(0, (80 - len(msg))) * '_' + msg) + # ------------------------------------------------------------------------ # Private `object` interface # ------------------------------------------------------------------------ @@ -925,6 +856,30 @@ def __repr__(self): location=self.store_backend.location,) +############################################################################### +# class `AsyncMemorizedFunc` +############################################################################### +class AsyncMemorizedFunc(MemorizedFunc): + async def __call__(self, *args, **kwargs): + out = super().__call__(*args, **kwargs) + return await out if asyncio.iscoroutine(out) else out + + async def call_and_shelve(self, *args, **kwargs): + out = super().call_and_shelve(*args, **kwargs) + return await out if asyncio.iscoroutine(out) else out + + async def call(self, *args, **kwargs): + out = super().call(*args, **kwargs) + return await out if asyncio.iscoroutine(out) else out + + async def _call(self, call_id, args, kwargs, shelving=False): + self._before_call(args, kwargs) + start_time = time.time() + output = await self.func(*args, **kwargs) + return self._after_call(call_id, args, kwargs, shelving, + output, start_time) + + ############################################################################### # class `Memory` ############################################################################### @@ -1072,14 +1027,20 @@ def cache(self, func=None, ignore=None, verbose=None, mmap_mode=False, cache_validation_callback=cache_validation_callback ) if self.store_backend is None: - return NotMemorizedFunc(func) + cls = (AsyncNotMemorizedFunc + if asyncio.iscoroutinefunction(func) + else NotMemorizedFunc) + return cls(func) if verbose is None: verbose = self._verbose if mmap_mode is False: mmap_mode = self.mmap_mode if isinstance(func, MemorizedFunc): func = func.func - return MemorizedFunc( + cls = (AsyncMemorizedFunc + if asyncio.iscoroutinefunction(func) + else MemorizedFunc) + return cls( func, location=self.store_backend, backend=self.backend, ignore=ignore, mmap_mode=mmap_mode, compress=self.compress, verbose=verbose, timestamp=self.timestamp, @@ -1187,7 +1148,7 @@ def expires_after(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, days, seconds, microseconds, milliseconds, minutes, hours, weeks: numbers argument passed to a timedelta. """ - delta = timedelta( + delta = datetime.timedelta( days=days, seconds=seconds, microseconds=microseconds, milliseconds=milliseconds, minutes=minutes, hours=hours, weeks=weeks )

diff --git a/joblib/test/test_memory.py b/joblib/test/test_memory.py index ec9761fd1..120987b66 100644 --- a/joblib/test/test_memory.py +++ b/joblib/test/test_memory.py @@ -571,8 +571,8 @@ def test_func_dir(tmpdir): assert g._check_previous_func_code() # Test the robustness to failure of loading previous results. - func_id, args_id = g._get_output_identifiers(1) - output_dir = os.path.join(g.store_backend.location, func_id, args_id) + args_id = g._get_args_id(1) + output_dir = os.path.join(g.store_backend.location, g.func_id, args_id) a = g(1) assert os.path.exists(output_dir) os.remove(os.path.join(output_dir, 'output.pkl')) @@ -587,10 +587,10 @@ def test_persistence(tmpdir): h = pickle.loads(pickle.dumps(g)) - func_id, args_id = h._get_output_identifiers(1) - output_dir = os.path.join(h.store_backend.location, func_id, args_id) + args_id = h._get_args_id(1) + output_dir = os.path.join(h.store_backend.location, h.func_id, args_id) assert os.path.exists(output_dir) - assert output == h.store_backend.load_item([func_id, args_id]) + assert output == h.store_backend.load_item([h.func_id, args_id]) memory2 = pickle.loads(pickle.dumps(memory)) assert memory.store_backend.location == memory2.store_backend.location @@ -668,9 +668,9 @@ def test_call_and_shelve_lazily_load_stored_result(tmpdir): memory = Memory(location=tmpdir.strpath, verbose=0) func = memory.cache(f) - func_id, argument_hash = func._get_output_identifiers(2) + args_id = func._get_args_id(2) result_path = os.path.join(memory.store_backend.location, - func_id, argument_hash, 'output.pkl') + func.func_id, args_id, 'output.pkl') assert func(2) == 5 first_access_time = os.stat(result_path).st_atime time.sleep(1) @@ -875,7 +875,7 @@ def get_1000_bytes(arg): get_1000_bytes(arg) func_id = _build_func_identifier(get_1000_bytes) - hash_dirnames = [get_1000_bytes._get_output_identifiers(arg)[1] + hash_dirnames = [get_1000_bytes._get_args_id(arg) for arg in inputs] full_hashdirs = [os.path.join(get_1000_bytes.store_backend.location, diff --git a/joblib/test/test_memory_async.py b/joblib/test/test_memory_async.py new file mode 100644 index 000000000..ecad0c926 --- /dev/null +++ b/joblib/test/test_memory_async.py @@ -0,0 +1,149 @@ +import asyncio +import gc +import shutil + +import pytest + +from joblib.memory import (AsyncMemorizedFunc, AsyncNotMemorizedFunc, + MemorizedResult, Memory, NotMemorizedResult) +from joblib.test.common import np, with_numpy +from joblib.testing import raises + +from .test_memory import (corrupt_single_cache_item, + monkeypatch_cached_func_warn) + + +async def check_identity_lazy_async(func, accumulator, location): + """ Similar to check_identity_lazy_async for coroutine functions""" + memory = Memory(location=location, verbose=0) + func = memory.cache(func) + for i in range(3): + for _ in range(2): + value = await func(i) + assert value == i + assert len(accumulator) == i + 1 + + +@pytest.mark.asyncio +async def test_memory_integration_async(tmpdir): + accumulator = list() + + async def f(n): + await asyncio.sleep(0.1) + accumulator.append(1) + return n + + await check_identity_lazy_async(f, accumulator, tmpdir.strpath) + + # Now test clearing + for compress in (False, True): + for mmap_mode in ('r', None): + memory = Memory(location=tmpdir.strpath, verbose=10, + mmap_mode=mmap_mode, compress=compress) + # First clear the cache directory, to check that our code can + # handle that + # NOTE: this line would raise an exception, as the database + # file is still open; we ignore the error since we want to + # test what happens if the directory disappears + shutil.rmtree(tmpdir.strpath, ignore_errors=True) + g = memory.cache(f) + await g(1) + g.clear(warn=False) + current_accumulator = len(accumulator) + out = await g(1) + + assert len(accumulator) == current_accumulator + 1 + # Also, check that Memory.eval works similarly + evaled = await memory.eval(f, 1) + assert evaled == out + assert len(accumulator) == current_accumulator + 1 + + # Now do a smoke test with a function defined in __main__, as the name + # mangling rules are more complex + f.__module__ = '__main__' + memory = Memory(location=tmpdir.strpath, verbose=0) + await memory.cache(f)(1) + + +@pytest.mark.asyncio +async def test_no_memory_async(): + accumulator = list() + + async def ff(x): + await asyncio.sleep(0.1) + accumulator.append(1) + return x + + memory = Memory(location=None, verbose=0) + gg = memory.cache(ff) + for _ in range(4): + current_accumulator = len(accumulator) + await gg(1) + assert len(accumulator) == current_accumulator + 1 + + +@with_numpy +@pytest.mark.asyncio +async def test_memory_numpy_check_mmap_mode_async(tmpdir, monkeypatch): + """Check that mmap_mode is respected even at the first call""" + + memory = Memory(location=tmpdir.strpath, mmap_mode='r', verbose=0) + + @memory.cache() + async def twice(a): + return a * 2 + + a = np.ones(3) + b = await twice(a) + c = await twice(a) + + assert isinstance(c, np.memmap) + assert c.mode == 'r' + + assert isinstance(b, np.memmap) + assert b.mode == 'r' + + # Corrupts the file, Deleting b and c mmaps + # is necessary to be able edit the file + del b + del c + gc.collect() + corrupt_single_cache_item(memory) + + # Make sure that corrupting the file causes recomputation and that + # a warning is issued. + recorded_warnings = monkeypatch_cached_func_warn(twice, monkeypatch) + d = await twice(a) + assert len(recorded_warnings) == 1 + exception_msg = 'Exception while loading results' + assert exception_msg in recorded_warnings[0] + # Asserts that the recomputation returns a mmap + assert isinstance(d, np.memmap) + assert d.mode == 'r' + + +@pytest.mark.asyncio +async def test_call_and_shelve_async(tmpdir): + async def f(x, y=1): + await asyncio.sleep(0.1) + return x ** 2 + y + + # Test MemorizedFunc outputting a reference to cache. + for func, Result in zip((AsyncMemorizedFunc(f, tmpdir.strpath), + AsyncNotMemorizedFunc(f), + Memory(location=tmpdir.strpath, + verbose=0).cache(f), + Memory(location=None).cache(f), + ), + (MemorizedResult, NotMemorizedResult, + MemorizedResult, NotMemorizedResult, + )): + for _ in range(2): + result = await func.call_and_shelve(2) + assert isinstance(result, Result) + assert result.get() == 5 + + result.clear() + with raises(KeyError): + result.get() + result.clear() # Do nothing if there is no cache.

diff --git a/CHANGES.rst b/CHANGES.rst index 5bf9c956e..e191018d6 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -4,11 +4,14 @@ Latest changes In development -------------- +- Allow caching co-routines with `Memory.cache`. + https://github.com/joblib/joblib/pull/894 + - Try to cast ``n_jobs`` to int in parallel and raise an error if it fails. This means that ``n_jobs=2.3`` will now result in ``effective_n_jobs=2`` instead of failing. https://github.com/joblib/joblib/pull/1539 - + - Ensure that errors in the task generator given to Parallel's call are raised in the results consumming thread. https://github.com/joblib/joblib/pull/1491 diff --git a/continuous_integration/install.sh b/continuous_integration/install.sh index c6fed2883..9668b7474 100755 --- a/continuous_integration/install.sh +++ b/continuous_integration/install.sh @@ -34,7 +34,7 @@ else fi # Install pytest timeout to fasten failure in deadlocking tests -PIP_INSTALL_PACKAGES="pytest-timeout threadpoolctl" +PIP_INSTALL_PACKAGES="pytest-timeout pytest-asyncio==0.21.1 threadpoolctl" if [ -n "$NUMPY_VERSION" ]; then # We want to ensure no memory copies are performed only when numpy is

[ { "components": [ { "doc": "", "lines": [ 203, 204 ], "name": "MemorizedResult.func", "signature": "def func(self):", "type": "function" }, { "doc": "", "lines": [ 207, 208 ], ...

[ "joblib/test/test_memory.py::test_memory_integration", "joblib/test/test_memory.py::test_parallel_call_cached_function_defined_in_jupyter[True]", "joblib/test/test_memory.py::test_parallel_call_cached_function_defined_in_jupyter[False]", "joblib/test/test_memory.py::test_no_memory", "joblib/test/test_memory...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> ENH allow caching coroutine functions Addresses #889, allowing coroutine functions (available in Python 3.5+) to be decorated with `joblib.memory`. In short, the decorated function's `__call__` and `call_and_shelve` are coroutine functions that when `await`ed return the output or `MemorizedResult`, respectively, that would normally return if the original function was not a coroutine. A small subset of tests were ported from `test_memory` to their asyncio equivalent to verify the expected behavior. In order to keep the asyncio-specific implementation as small as possible, I had to refactor a large portion of `memory.py` first. It's a separate commit so it can be reviewed and tested independently. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in joblib/memory.py] (definition of MemorizedResult.func:) def func(self): (definition of MemorizedResult.func_id:) def func_id(self): (definition of MemorizedResult.args_id:) def args_id(self): (definition of AsyncNotMemorizedFunc:) class AsyncNotMemorizedFunc(NotMemorizedFunc): (definition of MemorizedFunc._get_args_id:) def _get_args_id(self, *args, **kwargs): """Return the input parameter hash of a result.""" (definition of MemorizedFunc._call:) def _call(self, call_id, args, kwargs, shelving=False): (definition of MemorizedFunc._before_call:) def _before_call(self, args, kwargs): (definition of MemorizedFunc._after_call:) def _after_call(self, call_id, args, kwargs, shelving, output, start_time): (definition of MemorizedFunc._get_memorized_result:) def _get_memorized_result(self, call_id, metadata=None): (definition of MemorizedFunc._load_item:) def _load_item(self, call_id, metadata=None): (definition of MemorizedFunc._print_duration:) def _print_duration(self, duration, context=''): (definition of AsyncMemorizedFunc:) class AsyncMemorizedFunc(MemorizedFunc): [end of new definitions in joblib/memory.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

41b70ff10c293bd292465456434620e406d90d88

sympy__sympy-17030

17,030

sympy/sympy

1.5

a9751e4b979129ec399920e987569ca02bd9f3e4

2019-06-14T16:16:01Z

diff --git a/sympy/stats/rv.py b/sympy/stats/rv.py index 353a13974f9d..31ee14eb5ad7 100644 --- a/sympy/stats/rv.py +++ b/sympy/stats/rv.py @@ -280,7 +280,7 @@ def __new__(cls, idx_obj, pspace=None): return Basic.__new__(cls, idx_obj, pspace) symbol = property(lambda self: self.args[0]) - name = symbol + name = property(lambda self: str(self.args[0])) key = property(lambda self: self.symbol.args[1]) class ProductPSpace(PSpace): @@ -683,6 +683,9 @@ def expectation(expr, condition=None, numsamples=None, evaluate=True, **kwargs): if numsamples: # Computing by monte carlo sampling? return sampling_E(expr, condition, numsamples=numsamples) + if expr.has(RandomIndexedSymbol): + return pspace(expr).compute_expectation(expr, condition, evaluate, **kwargs) + # Create new expr and recompute E if condition is not None: # If there is a condition return expectation(given(expr, condition), evaluate=evaluate) @@ -737,7 +740,7 @@ def probability(condition, given_condition=None, numsamples=None, given_condition = sympify(given_condition) if condition.has(RandomIndexedSymbol): - return pspace(condition).probability(condition, given_condition, **kwargs) + return pspace(condition).probability(condition, given_condition, evaluate, **kwargs) if isinstance(given_condition, RandomSymbol): condrv = random_symbols(condition) diff --git a/sympy/stats/stochastic_process.py b/sympy/stats/stochastic_process.py index 4520830e1f31..5b012ec790e8 100644 --- a/sympy/stats/stochastic_process.py +++ b/sympy/stats/stochastic_process.py @@ -2,7 +2,7 @@ from sympy import Basic, Symbol from sympy.core.compatibility import string_types -from sympy.stats.rv import ProductDomain +from sympy.stats.rv import ProductDomain, _symbol_converter from sympy.stats.joint_rv import ProductPSpace, JointRandomSymbol class StochasticPSpace(ProductPSpace): @@ -11,19 +11,20 @@ class StochasticPSpace(ProductPSpace): and their random variables. Contains mechanics to do computations for queries of stochastic processes. - Initialized by symbol and the specific process. + Initialized by symbol, the specific process and + distribution(optional) if the random indexed symbols + of the process follows any specific distribution, like, + in Bernoulli Process, each random indexed symbol follows + Bernoulli distribution. For processes with memory, this + parameter should not be passed. """ - def __new__(cls, sym, process): - if isinstance(sym, string_types): - sym = Symbol(sym) - if not isinstance(sym, Symbol): - raise TypeError("Name of stochastic process should be either only " - "a string or Symbol.") + def __new__(cls, sym, process, distribution=None): + sym = _symbol_converter(sym) from sympy.stats.stochastic_process_types import StochasticProcess if not isinstance(process, StochasticProcess): raise TypeError("`process` must be an instance of StochasticProcess.") - return Basic.__new__(cls, sym, process) + return Basic.__new__(cls, sym, process, distribution) @property def process(self): @@ -41,37 +42,22 @@ def domain(self): def symbol(self): return self.args[0] - def probability(self, condition, given_condition=None, **kwargs): + @property + def distribution(self): + return self.args[2] + + def probability(self, condition, given_condition=None, evaluate=True, **kwargs): """ Transfers the task of handling queries to the specific stochastic process because every process has their own logic of handling such queries. """ - return self.process.probability(condition, given_condition, **kwargs) + return self.process.probability(condition, given_condition, evaluate, **kwargs) - def joint_distribution(self, *args): + def compute_expectation(self, expr, condition=None, evaluate=True, **kwargs): """ - Computes the joint distribution of the random indexed variables. - - Parameters - ========== - - args: iterable - The finite list of random indexed variables of a stochastic - process whose joint distribution has to be computed. - - Returns - ======= - - JointDistribution - The joint distribution of the list of random indexed variables. - An unevaluated object is returned if it is not possible to - compute the joint distribution. - - Raises - ====== - - ValueError: When the time/key of random indexed variables - is not in strictly increasing order. + Transfers the task of handling queries to the specific stochastic + process because every process has their own logic of handling such + queries. """ - NotImplementedError() + return self.process.expectation(expr, condition, evaluate, **kwargs) diff --git a/sympy/stats/stochastic_process_types.py b/sympy/stats/stochastic_process_types.py index d6eefdc066fb..8f8d896266cd 100644 --- a/sympy/stats/stochastic_process_types.py +++ b/sympy/stats/stochastic_process_types.py @@ -1,11 +1,12 @@ from sympy import (Symbol, Matrix, MatrixSymbol, S, Indexed, Basic, Set, And, Tuple, Eq, FiniteSet, ImmutableMatrix, - nsimplify) + nsimplify, Lambda, Mul, Sum, Dummy, Lt) from sympy.stats.rv import (RandomIndexedSymbol, random_symbols, RandomSymbol, _symbol_converter) +from sympy.stats.joint_rv import JointDistributionHandmade, JointDistribution from sympy.core.compatibility import string_types from sympy.core.relational import Relational -from sympy.stats.symbolic_probability import Probability +from sympy.stats.symbolic_probability import Probability, Expectation from sympy.stats.stochastic_process import StochasticPSpace from sympy.logic.boolalg import Boolean @@ -71,7 +72,9 @@ class StochasticProcess(Basic): DiscreteTimeStochasticProcess """ - def __new__(cls, sym, state_space=S.Reals): + index_set = S.Reals + + def __new__(cls, sym, state_space=S.Reals, **kwargs): sym = _symbol_converter(sym) state_space = _set_converter(state_space) return Basic.__new__(cls, sym, state_space) @@ -99,6 +102,53 @@ def __getitem__(self, time): def probability(self, condition): raise NotImplementedError() + def joint_distribution(self, *args): + """ + Computes the joint distribution of the random indexed variables. + + Parameters + ========== + + args: iterable + The finite list of random indexed variables/the key of a stochastic + process whose joint distribution has to be computed. + + Returns + ======= + + JointDistribution + The joint distribution of the list of random indexed variables. + An unevaluated object is returned if it is not possible to + compute the joint distribution. + + Raises + ====== + + ValueError: When the arguments passed are not of type RandomIndexSymbol + or Number. + """ + args = list(args) + for i, arg in enumerate(args): + if S(arg).is_Number: + if self.index_set.is_subset(S.Integers): + args[i] = self.__getitem__(arg) + else: + args[i] = self.__call__(arg) + elif not isinstance(arg, RandomIndexedSymbol): + raise ValueError("Expected a RandomIndexedSymbol or " + "key not %s"%(type(arg))) + + if args[0].pspace.distribution == None: # checks if there is any distribution available + return JointDistribution(*args) + # TODO: Add tests for the below part of the method, when implementation of Bernoulli Process + # is completed + pdf = Lambda(*[arg.name for arg in args], + expr=Mul.fromiter(arg.pspace.distribution.pdf(arg) for arg in args)) + return JointDistributionHandmade(pdf) + + def expectation(self, condition, given_condition): + raise NotImplementedError("Abstract method for expectation queries.") + class DiscreteTimeStochasticProcess(StochasticProcess): """ Base class for all discrete stochastic processes. @@ -182,6 +232,8 @@ class DiscreteMarkovChain(DiscreteTimeStochasticProcess): 0.36 """ + is_markov = True + index_set = S.Naturals0 def __new__(cls, sym, state_space=S.Reals, trans_probs=None): @@ -199,36 +251,11 @@ def transition_probabilities(self): """ return self.args[2] - def probability(self, condition, given_condition, **kwargs): + def _extract_information(self, given_condition): """ - Handles probability queries for discrete Markov chains. - - Parameters - ========== - - condition: Relational - given_condition: Relational/And - - Returns - ======= - - Probability - If the transition probabilities are not available - Expr - If the transition probabilities is MatrixSymbol or Matrix - - Note - ==== - - Any information passed at the time of query overrides - any information passed at the time of object creation like - transition probabilities, state space. - - Pass the transition matrix using TransitionMatrixOf and state space - using StochasticStateSpaceOf in given_condition using & or And. + Helper function to extract information, like, + transition probabilities, state space, etc. """ - - # extracting transition matrix and state space trans_probs, state_space = self.transition_probabilities, self.state_space if isinstance(given_condition, And): gcs = given_condition.args @@ -243,14 +270,13 @@ def probability(self, condition, given_condition, **kwargs): trans_probs = given_condition.matrix if isinstance(given_condition, StochasticStateSpaceOf): state_space = given_condition.state_space + return trans_probs, state_space, given_condition - # given_condition does not have sufficient information - # for computations - if trans_probs == None or \ - given_condition == None: - return Probability(condition, given_condition, **kwargs) - - # working out transition probabilities + def _check_trans_probs(self, trans_probs): + """ + Helper function for checking the validity of transition + probabilities. + """ if not isinstance(trans_probs, MatrixSymbol): rows = trans_probs.tolist() for row in rows: @@ -258,6 +284,11 @@ def probability(self, condition, given_condition, **kwargs): raise ValueError("Probabilities in a row must sum to 1. " "If you are using Float or floats then please use Rational.") + def _work_out_state_space(self, state_space, given_condition, trans_probs): + """ + Helper function to extract state space if there + is a random symbol in the given condition. + """ # if given condition is None, then there is no need to work out # state_space from random variables if given_condition != None: @@ -267,6 +298,68 @@ def probability(self, condition, given_condition, **kwargs): state_space = rand_var[0].pspace.set if not FiniteSet(*[i for i in range(trans_probs.shape[0])]).is_subset(state_space): raise ValueError("state space is not compatible with the transition probabilites.") + return state_space + + def _preprocess(self, given_condition, evaluate): + """ + Helper function for pre-processing the information. + """ + is_insufficient = False + + if not evaluate: # avoid pre-processing if the result is not to be evaluated + return (True, None, None, None) + + # extracting transition matrix and state space + trans_probs, state_space, given_condition = self._extract_information(given_condition) + + # given_condition does not have sufficient information + # for computations + if trans_probs == None or \ + given_condition == None: + is_insufficient = True + else: + # checking transition probabilities + self._check_trans_probs(trans_probs) + + # working out state space + state_space = self._work_out_state_space(state_space, given_condition, trans_probs) + + return is_insufficient, trans_probs, state_space, given_condition + + def probability(self, condition, given_condition=None, evaluate=True, **kwargs): + """ + Handles probability queries for discrete Markov chains. + + Parameters + ========== + + condition: Relational + given_condition: Relational/And + + Returns + ======= + + Probability + If the transition probabilities are not available + Expr + If the transition probabilities is MatrixSymbol or Matrix + + Note + ==== + + Any information passed at the time of query overrides + any information passed at the time of object creation like + transition probabilities, state space. + + Pass the transition matrix using TransitionMatrixOf and state space + using StochasticStateSpaceOf in given_condition using & or And. + """ + + check, trans_probs, state_space, given_condition = \ + self._preprocess(given_condition, evaluate) + + if check: + return Probability(condition, given_condition) if isinstance(condition, Eq) and \ isinstance(given_condition, Eq) and \ @@ -279,7 +372,7 @@ def probability(self, condition, given_condition, **kwargs): if not isinstance(lhsg, RandomIndexedSymbol): lhsg, rhsg = (rhsg, lhsg) keyc, statec, keyg, stateg = (lhsc.key, rhsc, lhsg.key, rhsg) - if stateg >= trans_probs.shape[0] == False or statec >= trans_probs.shape[1]: + if Lt(stateg, trans_probs.shape[0]) == False or Lt(statec, trans_probs.shape[1]) == False: raise IndexError("No information is avaliable for (%s, %s) in " "transition probabilities of shape, (%s, %s). " "State space is zero indexed." @@ -312,3 +405,62 @@ def probability(self, condition, given_condition, **kwargs): raise NotImplementedError("Mechanism for handling (%s, %s) queries hasn't been " "implemented yet."%(condition, given_condition)) + + def expectation(self, expr, condition=None, evaluate=True, **kwargs): + """ + Handles expectation queries for discrete markov chains. + + Parameters + ========== + + expr: RandomIndexedSymbol, Relational, Logic + Condition for which expectation has to be computed. Must + contain a RandomIndexedSymbol of the process. + condition: Relational, Logic + The given conditions under which computations should be done. + + Returns + ======= + + Expectation + Unevaluated object if computations cannot be done due to + insufficient information. + Expr + In all other cases when the computations are successfull. + + Note + ==== + + Any information passed at the time of query overrides + any information passed at the time of object creation like + transition probabilities, state space. + + Pass the transition matrix using TransitionMatrixOf and state space + using StochasticStateSpaceOf in given_condition using & or And. + """ + + check, trans_probs, state_space, condition = \ + self._preprocess(condition, evaluate) + + if check: + return Expectation(expr, condition) + + if isinstance(expr, RandomIndexedSymbol): + if isinstance(condition, Eq): + # handle queries similar to E(X[i], Eq(X[i-m], <some-state>)) + lhsg, rhsg = condition.lhs, condition.rhs + if not isinstance(lhsg, RandomIndexedSymbol): + lhsg, rhsg = (rhsg, lhsg) + if rhsg not in self.state_space: + raise ValueError("%s state is not in the state space."%(rhsg)) + if expr.key < lhsg.key: + raise ValueError("Incorrect given condition is given, expectation " + "time %s < time %s"%(expr.key, lhsg.key)) + cond = condition & TransitionMatrixOf(self, trans_probs) & \ + StochasticStateSpaceOf(self, state_space) + s = Dummy('s') + func = Lambda(s, self.probability(Eq(expr, s), cond)*s) + return Sum(func(s), (s, state_space.inf, state_space.sup)).doit() + + raise NotImplementedError("Mechanism for handling (%s, %s) queries hasn't been " + "implemented yet."%(expr, condition))

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 44b4bd07b751..8781cdc48a6d 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1551,7 +1551,8 @@ def test_sympy__stats__rv__RandomIndexedSymbol(): def test_sympy__stats__stochastic_process__StochasticPSpace(): from sympy.stats.stochastic_process import StochasticPSpace from sympy.stats.stochastic_process_types import StochasticProcess - assert _test_args(StochasticPSpace("Y", StochasticProcess("Y", [1, 2, 3]))) + from sympy.stats.frv_types import BernoulliDistribution + assert _test_args(StochasticPSpace("Y", StochasticProcess("Y", [1, 2, 3]), BernoulliDistribution(S(1)/2, 1, 0))) def test_sympy__stats__stochastic_process_types__StochasticProcess(): from sympy.stats.stochastic_process_types import StochasticProcess diff --git a/sympy/stats/tests/test_stochastic_process.py b/sympy/stats/tests/test_stochastic_process.py index cd974e42afb0..3f459ebf9cb9 100644 --- a/sympy/stats/tests/test_stochastic_process.py +++ b/sympy/stats/tests/test_stochastic_process.py @@ -1,7 +1,8 @@ from sympy import (S, symbols, FiniteSet, Eq, Matrix, MatrixSymbol, Float, And) -from sympy.stats import DiscreteMarkovChain, P, TransitionMatrixOf +from sympy.stats import DiscreteMarkovChain, P, TransitionMatrixOf, E from sympy.stats.rv import RandomIndexedSymbol -from sympy.stats.symbolic_probability import Probability +from sympy.stats.symbolic_probability import Probability, Expectation +from sympy.stats.joint_rv import JointDistribution from sympy.utilities.pytest import raises def test_DiscreteMarkovChain(): @@ -13,25 +14,41 @@ def test_DiscreteMarkovChain(): assert X.transition_probabilities == None t = symbols('t', positive=True, integer=True) assert isinstance(X[t], RandomIndexedSymbol) + assert E(X[0]) == Expectation(X[0]) + raises(TypeError, lambda: DiscreteMarkovChain(1)) + raises(NotImplementedError, lambda: X(t)) # pass name and state_space Y = DiscreteMarkovChain("Y", [1, 2, 3]) assert Y.transition_probabilities == None assert Y.state_space == FiniteSet(1, 2, 3) assert P(Eq(Y[2], 1), Eq(Y[0], 2)) == Probability(Eq(Y[2], 1), Eq(Y[0], 2)) + assert E(X[0]) == Expectation(X[0]) + raises(TypeError, lambda: DiscreteMarkovChain("Y", dict((1, 1)))) # pass name, state_space and transition_probabilities T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]]) TS = MatrixSymbol('T', 3, 3) Y = DiscreteMarkovChain("Y", [0, 1, 2], T) YS = DiscreteMarkovChain("Y", [0, 1, 2], TS) + assert Y.joint_distribution(1, Y[2], 3) == JointDistribution(Y[1], Y[2], Y[3]) + raises(ValueError, lambda: Y.joint_distribution(Y[1].symbol, Y[2].symbol)) assert P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) == Float(0.36, 2) assert str(P(Eq(YS[3], 2), Eq(YS[1], 1))) == \ "T[0, 2]*T[1, 0] + T[1, 1]*T[1, 2] + T[1, 2]*T[2, 2]" TO = Matrix([[0.25, 0.75, 0],[0, 0.25, 0.75],[0.75, 0, 0.25]]) assert P(Eq(Y[3], 2), Eq(Y[1], 1) & TransitionMatrixOf(Y, TO)).round(3) == Float(0.375, 3) + assert E(Y[3], evaluate=False) == Expectation(Y[3]) + assert E(Y[3], Eq(Y[2], 1)).round(2) == Float(1.1, 3) TSO = MatrixSymbol('T', 4, 4) raises(ValueError, lambda: str(P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TSO)))) + raises(TypeError, lambda: DiscreteMarkovChain("Z", [0, 1, 2], symbols('M'))) + raises(ValueError, lambda: DiscreteMarkovChain("Z", [0, 1, 2], MatrixSymbol('T', 3, 4))) + raises(IndexError, lambda: str(P(Eq(YS[3], 3), Eq(YS[1], 1)))) + raises(ValueError, lambda: str(P(Eq(YS[1], 1), Eq(YS[2], 2)))) + raises(ValueError, lambda: E(Y[3], Eq(Y[2], 6))) + raises(ValueError, lambda: E(Y[2], Eq(Y[3], 1))) + # extended tests for probability queries TO1 = Matrix([[S(1)/4, S(3)/4, 0],[S(1)/3, S(1)/3, S(1)/3],[0, S(1)/4, S(3)/4]]) @@ -39,3 +56,4 @@ def test_DiscreteMarkovChain(): Eq(Probability(Eq(Y[0], 0)), S(1)/4) & TransitionMatrixOf(Y, TO1)) == S(1)/16 assert P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)), TransitionMatrixOf(Y, TO1)) == \ Probability(Eq(Y[0], 0))/4 + raises (ValueError, lambda: str(P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)), Eq(Y[1], 1))))

[ { "components": [ { "doc": "", "lines": [ 46, 47 ], "name": "StochasticPSpace.distribution", "signature": "def distribution(self):", "type": "function" }, { "doc": "Transfers the task of handling queries to the specifi...

[ "test_sympy__stats__stochastic_process__StochasticPSpace" ]

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Adding more features to StochasticProcess  #### References to other Issues or PRs  [1] https://github.com/sympy/sympy/pull/16981 #### Brief description of what is fixed or changed `joint_dsitribution` has been added to `StochasticProcess`. Test coverage has also been increased. #### Other comments More features like, `compute_expectation` will be added to the `StochasticProcess`. Provide your suggestions in the comments, if something more can be added. :) #### Release Notes   * stats * `joint_distribution` added to `StochasticProcess`.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/stochastic_process.py] (definition of StochasticPSpace.distribution:) def distribution(self): (definition of StochasticPSpace.compute_expectation:) def compute_expectation(self, expr, condition=None, evaluate=True, **kwargs): """Transfers the task of handling queries to the specific stochastic process because every process has their own logic of handling such queries.""" [end of new definitions in sympy/stats/stochastic_process.py] [start of new definitions in sympy/stats/stochastic_process_types.py] (definition of StochasticProcess.joint_distribution:) def joint_distribution(self, *args): """Computes the joint distribution of the random indexed variables. Parameters ========== args: iterable The finite list of random indexed variables/the key of a stochastic process whose joint distribution has to be computed. Returns ======= JointDistribution The joint distribution of the list of random indexed variables. An unevaluated object is returned if it is not possible to compute the joint distribution. Raises ====== ValueError: When the arguments passed are not of type RandomIndexSymbol or Number.""" (definition of StochasticProcess.expectation:) def expectation(self, condition, given_condition): (definition of DiscreteMarkovChain._extract_information:) def _extract_information(self, given_condition): """Helper function to extract information, like, transition probabilities, state space, etc.""" (definition of DiscreteMarkovChain._check_trans_probs:) def _check_trans_probs(self, trans_probs): """Helper function for checking the validity of transition probabilities.""" (definition of DiscreteMarkovChain._work_out_state_space:) def _work_out_state_space(self, state_space, given_condition, trans_probs): """Helper function to extract state space if there is a random symbol in the given condition.""" (definition of DiscreteMarkovChain._preprocess:) def _preprocess(self, given_condition, evaluate): """Helper function for pre-processing the information.""" (definition of DiscreteMarkovChain.expectation:) def expectation(self, expr, condition=None, evaluate=True, **kwargs): """Handles expectation queries for discrete markov chains. Parameters ========== expr: RandomIndexedSymbol, Relational, Logic Condition for which expectation has to be computed. Must contain a RandomIndexedSymbol of the process. condition: Relational, Logic The given conditions under which computations should be done. Returns ======= Expectation Unevaluated object if computations cannot be done due to insufficient information. Expr In all other cases when the computations are successfull. Note ==== Any information passed at the time of query overrides any information passed at the time of object creation like transition probabilities, state space. Pass the transition matrix using TransitionMatrixOf and state space using StochasticStateSpaceOf in given_condition using & or And.""" [end of new definitions in sympy/stats/stochastic_process_types.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-17019

17,019

sympy/sympy

1.5

3febfc43ca0aa23d916ef06057e8c6d396a955e7

2019-06-12T16:45:32Z

diff --git a/sympy/assumptions/refine.py b/sympy/assumptions/refine.py index 0ed132bee5ae..52099d71abe7 100644 --- a/sympy/assumptions/refine.py +++ b/sympy/assumptions/refine.py @@ -240,6 +240,57 @@ def refine_Relational(expr, assumptions): return ask(Q.is_true(expr), assumptions) +def refine_re(expr, assumptions): + """ + Handler for real part. + + >>> from sympy.assumptions.refine import refine_re + >>> from sympy import Q, re + >>> from sympy.abc import x + >>> refine_re(re(x), Q.real(x)) + x + >>> refine_re(re(x), Q.imaginary(x)) + 0 + """ + arg = expr.args[0] + if ask(Q.real(arg), assumptions): + return arg + if ask(Q.imaginary(arg), assumptions): + return 0 + return _refine_reim(expr, assumptions) + + +def refine_im(expr, assumptions): + """ + Handler for imaginary part. + + >>> from sympy.assumptions.refine import refine_im + >>> from sympy import Q, im + >>> from sympy.abc import x + >>> refine_im(im(x), Q.real(x)) + 0 + >>> refine_im(im(x), Q.imaginary(x)) + -I*x + """ + arg = expr.args[0] + if ask(Q.real(arg), assumptions): + return 0 + if ask(Q.imaginary(arg), assumptions): + return - S.ImaginaryUnit * arg + return _refine_reim(expr, assumptions) + + +def _refine_reim(expr, assumptions): + # Helper function for refine_re & refine_im + expanded = expr.expand(complex = True) + if expanded != expr: + refined = refine(expanded, assumptions) + if refined != expanded: + return refined + # Best to leave the expression as is + return None + + handlers_dict = { 'Abs': refine_abs, 'Pow': refine_Pow, @@ -249,5 +300,7 @@ def refine_Relational(expr, assumptions): 'GreaterThan': refine_Relational, 'LessThan': refine_Relational, 'StrictGreaterThan': refine_Relational, - 'StrictLessThan': refine_Relational + 'StrictLessThan': refine_Relational, + 're': refine_re, + 'im': refine_im }

diff --git a/sympy/assumptions/tests/test_refine.py b/sympy/assumptions/tests/test_refine.py index 0fd1ef8031af..15f9878c37d9 100644 --- a/sympy/assumptions/tests/test_refine.py +++ b/sympy/assumptions/tests/test_refine.py @@ -1,6 +1,6 @@ from sympy import (Abs, exp, Expr, I, pi, Q, Rational, refine, S, sqrt, - atan, atan2, nan, Symbol) -from sympy.abc import x, y, z + atan, atan2, nan, Symbol, re, im) +from sympy.abc import w, x, y, z from sympy.core.relational import Eq, Ne from sympy.functions.elementary.piecewise import Piecewise from sympy.utilities.pytest import slow @@ -145,6 +145,39 @@ def test_atan2(): assert refine(atan2(y, x), Q.zero(y) & Q.zero(x)) == nan +def test_re(): + assert refine(re(x), Q.real(x)) == x + assert refine(re(x), Q.imaginary(x)) == 0 + assert refine(re(x+y), Q.real(x) & Q.real(y)) == x + y + assert refine(re(x+y), Q.real(x) & Q.imaginary(y)) == x + assert refine(re(x*y), Q.real(x) & Q.real(y)) == x * y + assert refine(re(x*y), Q.real(x) & Q.imaginary(y)) == 0 + assert refine(re(x*y*z), Q.real(x) & Q.real(y) & Q.real(z)) == x * y * z + + +def test_im(): + assert refine(im(x), Q.imaginary(x)) == -I*x + assert refine(im(x), Q.real(x)) == 0 + assert refine(im(x+y), Q.imaginary(x) & Q.imaginary(y)) == -I*x - I*y + assert refine(im(x+y), Q.real(x) & Q.imaginary(y)) == -I*y + assert refine(im(x*y), Q.imaginary(x) & Q.real(y)) == -I*x*y + assert refine(im(x*y), Q.imaginary(x) & Q.imaginary(y)) == 0 + assert refine(im(1/x), Q.imaginary(x)) == -I/x + assert refine(im(x*y*z), Q.imaginary(x) & Q.imaginary(y) + & Q.imaginary(z)) == -I*x*y*z + + +def test_complex(): + assert refine(re(1/(x + I*y)), Q.real(x) & Q.real(y)) == \ + x/(x**2 + y**2) + assert refine(im(1/(x + I*y)), Q.real(x) & Q.real(y)) == \ + -y/(x**2 + y**2) + assert refine(re((w + I*x) * (y + I*z)), Q.real(w) & Q.real(x) & Q.real(y) + & Q.real(z)) == w*y - x*z + assert refine(im((w + I*x) * (y + I*z)), Q.real(w) & Q.real(x) & Q.real(y) + & Q.real(z)) == w*z + x*y + + def test_func_args(): class MyClass(Expr): # A class with nontrivial .func

[ { "components": [ { "doc": "Handler for real part.\n\n>>> from sympy.assumptions.refine import refine_re\n>>> from sympy import Q, re\n>>> from sympy.abc import x\n>>> refine_re(re(x), Q.real(x))\nx\n>>> refine_re(re(x), Q.imaginary(x))\n0", "lines": [ 243, 260 ...

[ "test_re", "test_im", "test_complex" ]

[ "test_Abs", "test_pow1", "test_exp", "test_Relational", "test_Piecewise", "test_atan2", "test_func_args", "test_eval_refine" ]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add refine handlers for re(), im().  #### References to other Issues or PRs  Issue #17011 #### Brief description of what is fixed or changed Added two methods ``` refine_re() ``` & ``` refine_im() ``` in ``` sympy.assumptions.refine.py ``` along with tests. #### Other comments I wasn't sure how to handle cases where there wasn't enough information about the variables. With the current changes, ``` refine(re(x*y)) ``` gives ``` re(x)*re(y) - im(x)*im(y) ``` which might actually be less preferable than ``` re(x*y) ```. #### Release Notes   * assumptions * add refine_re() , refine_im()  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/assumptions/refine.py] (definition of refine_re:) def refine_re(expr, assumptions): """Handler for real part. >>> from sympy.assumptions.refine import refine_re >>> from sympy import Q, re >>> from sympy.abc import x >>> refine_re(re(x), Q.real(x)) x >>> refine_re(re(x), Q.imaginary(x)) 0""" (definition of refine_im:) def refine_im(expr, assumptions): """Handler for imaginary part. >>> from sympy.assumptions.refine import refine_im >>> from sympy import Q, im >>> from sympy.abc import x >>> refine_im(im(x), Q.real(x)) 0 >>> refine_im(im(x), Q.imaginary(x)) -I*x""" (definition of _refine_reim:) def _refine_reim(expr, assumptions): [end of new definitions in sympy/assumptions/refine.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-16991

16,991

sympy/sympy

1.5

8f4999d744827bc6b29e05e8ec4e6bc1bf8a5d11

2019-06-08T12:04:27Z

diff --git a/doc/src/modules/combinatorics/index.rst b/doc/src/modules/combinatorics/index.rst index f753a41ae16a..2d70a46a13ee 100644 --- a/doc/src/modules/combinatorics/index.rst +++ b/doc/src/modules/combinatorics/index.rst @@ -23,3 +23,4 @@ Contents testutil.rst tensor_can.rst fp_groups.rst + pc_groups.rst diff --git a/doc/src/modules/combinatorics/pc_groups.rst b/doc/src/modules/combinatorics/pc_groups.rst new file mode 100644 index 000000000000..4114bbebebfd --- /dev/null +++ b/doc/src/modules/combinatorics/pc_groups.rst @@ -0,0 +1,12 @@ +.. _combinatorics-pc_groups: + +Polycyclic Groups +================= + +.. module:: sympy.combinatorics.pc_groups + +.. autoclass:: PolycyclicGroup + :members: + +.. autoclass:: Collector + :members: \ No newline at end of file diff --git a/sympy/combinatorics/__init__.py b/sympy/combinatorics/__init__.py index dae9c62de88d..c620fb1b38fa 100644 --- a/sympy/combinatorics/__init__.py +++ b/sympy/combinatorics/__init__.py @@ -11,3 +11,4 @@ from sympy.combinatorics.graycode import GrayCode from sympy.combinatorics.named_groups import (SymmetricGroup, DihedralGroup, CyclicGroup, AlternatingGroup, AbelianGroup, RubikGroup) +from sympy.combinatorics.pc_groups import PolycyclicGroup, Collector diff --git a/sympy/combinatorics/pc_groups.py b/sympy/combinatorics/pc_groups.py new file mode 100644 index 000000000000..25507b375fa8 --- /dev/null +++ b/sympy/combinatorics/pc_groups.py @@ -0,0 +1,490 @@ +from sympy.core import Basic +from sympy import isprime, symbols +from sympy.combinatorics.perm_groups import PermutationGroup +from sympy.printing.defaults import DefaultPrinting +from sympy.combinatorics.free_groups import free_group + +class PolycyclicGroup(DefaultPrinting): + + is_group = True + is_solvable = True + + def __init__(self, pc_sequence, pc_series, relative_order, collector=None): + self.pcgs = pc_sequence + self.pc_series = pc_series + self.relative_order = relative_order + self.collector = Collector(self.pcgs, pc_series, relative_order) if not collector else collector + + def is_prime_order(self): + return all(isprime(order) for order in self.relative_order) + + def length(self): + return len(self.pcgs) + + +class Collector(DefaultPrinting): + + """ + References + ========== + + .. [1] Holt, D., Eick, B., O'Brien, E. + "Handbook of Computational Group Theory" + Section 8.1.3 + """ + + def __init__(self, pcgs, pc_series, relative_order, group=None, pc_presentation=None): + self.pcgs = pcgs + self.pc_series = pc_series + self.relative_order = relative_order + self.free_group = free_group('x:{0}'.format(len(pcgs)))[0] if not group else group + self.index = {s: i for i, s in enumerate(self.free_group.symbols)} + self.pc_presentation = self.pc_relators() + + def minimal_uncollected_subword(self, word): + """ + Returns the minimal uncollected subwords. + + A word `v` defined on generators in `X` is a minimal + uncollected subword of the word `w` if `v` is a subword + of `w` and it has one of the following form + + i) `v = x[i+1]**a_j*x[i]` + + ii) `v = x[i+1]**a_j*x[i]**-1` + + iii) `v = x[i]**a_j` for relative_order of `x[i] != infinity` + and `a_j` is not in `{1, ..., s-1}`. Where, s is the power + exponent of the corresponding generator. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> from sympy.combinatorics.free_groups import free_group + >>> G = SymmetricGroup(4) + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> F, x1, x2 = free_group("x1, x2") + >>> word = x2**2*x1**7 + >>> collector.minimal_uncollected_subword(word) + ((x2, 2),) + + """ + # To handle the case word = <identity> + if not word: + return None + + array = word.array_form + re = self.relative_order + index = self.index + + for i in range(len(array)): + s1, e1 = array[i] + + if re[index[s1]] and (e1 < 0 or e1 > re[index[s1]]-1): + return ((s1, e1), ) + + for i in range(len(array)-1): + s1, e1 = array[i] + s2, e2 = array[i+1] + + if index[s1] > index[s2]: + e = 1 if e2 > 0 else -1 + return ((s1, e1), (s2, e)) + + return None + + def relations(self): + """ + Separates the given relators of pc presentation in power and + conjugate relations. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> G = SymmetricGroup(3) + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> power_rel, conj_rel = collector.relations() + >>> power_rel + {x0**2: (), x1**3: ()} + >>> conj_rel + {x0**-1*x1*x0: x1**2} + + """ + power_relators = {} + conjugate_relators = {} + for key, value in self.pc_presentation.items(): + if len(key.array_form) == 1: + power_relators[key] = value + else: + conjugate_relators[key] = value + return power_relators, conjugate_relators + + def subword_index(self, word, w): + """ + Returns the start and ending index of a given + subword in a word. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> from sympy.combinatorics.free_groups import free_group + >>> G = SymmetricGroup(4) + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> F, x1, x2 = free_group("x1, x2") + >>> word = x2**2*x1**7 + >>> w = x2**2*x1 + >>> collector.subword_index(word, w) + (0, 3) + >>> w = x1**7 + >>> collector.subword_index(word, w) + (2, 9) + + """ + low = -1 + high = -1 + for i in range(len(word)-len(w)+1): + if word.subword(i, i+len(w)) == w: + low = i + high = i+len(w) + break + if low == high == -1: + return -1, -1 + return low, high + + def map_relation(self, w): + """ + Return a conjugate relation. + Given a word formed by two free group elements, the + corresponding conjugate relation with those free + group elements is formed and mapped with the collected + word in the polycyclic presentation. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> from sympy.combinatorics.free_groups import free_group + >>> G = SymmetricGroup(3) + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> F, x0, x1 = free_group("x0, x1") + >>> w = x1*x0 + >>> collector.map_relation(w) + x1**2 + + """ + array = w.array_form + s1 = array[0][0] + s2 = array[1][0] + key = ((s2, -1), (s1, 1), (s2, 1)) + key = self.free_group.dtype(key) + return self.pc_presentation[key] + + + def collected_word(self, word): + """ + Return the collected form of a word. + + A word `w` is called collected, if `w = x{i_1}**a_1*...*x{i_r}**a_r` + with `i_1 < i_2< ... < i_r` and `a_j` is in `{1, ..., s_j-1}` + if `s_j != infinity`. + Otherwise w is uncollected. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> from sympy.combinatorics.perm_groups import PermutationGroup + >>> from sympy.combinatorics.free_groups import free_group + >>> G = SymmetricGroup(4) + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> F, x0, x1, x2, x3 = free_group("x0, x1, x2, x3") + >>> word = x3*x2*x1*x0 + >>> collected_word = collector.collected_word(word) + >>> free_to_perm = {} + >>> free_group = collector.free_group + >>> for sym, gen in zip(free_group.symbols, collector.pcgs): + ... free_to_perm[sym] = gen + >>> G1 = PermutationGroup() + >>> for w in word: + ... sym = w[0] + ... perm = free_to_perm[sym] + ... G1 = PermutationGroup([perm] + G1.generators) + >>> G2 = PermutationGroup() + >>> for w in collected_word: + ... sym = w[0] + ... perm = free_to_perm[sym] + ... G2 = PermutationGroup([perm] + G2.generators) + >>> G1 == G2 + True + + """ + free_group = self.free_group + while True: + w = self.minimal_uncollected_subword(word) + if not w: + break + + low, high = self.subword_index(word, free_group.dtype(w)) + if low == -1: + continue + + s1, e1 = w[0] + if len(w) == 1: + re = self.relative_order[self.index[s1]] + q = e1 // re + r = e1-q*re + + key = ((w[0][0], re), ) + key = free_group.dtype(key) + if self.pc_presentation[key]: + word_ = ((w[0][0], r), (self.pc_presentation[key], q)) + word_ = free_group.dtype(word_) + else: + if r != 0: + word_ = ((w[0][0], r), ) + word_ = free_group.dtype(word_) + else: + word_ = None + word = word.eliminate_word(free_group.dtype(w), word_) + + if len(w) == 2 and w[1][1] > 0: + s2, e2 = w[1] + s2 = ((s2, 1), ) + s2 = free_group.dtype(s2) + word_ = self.map_relation(free_group.dtype(w)) + word_ = s2*word_**e1 + word_ = free_group.dtype(word_) + word = word.substituted_word(low, high, word_) + + elif len(w) == 2 and w[1][1] < 0: + s2, e2 = w[1] + s2 = ((s2, 1), ) + s2 = free_group.dtype(s2) + word_ = self.map_relation(free_group.dtype(w)) + word_ = s2**-1*word_**e1 + word_ = free_group.dtype(word_) + word = word.substituted_word(low, high, word_) + + return word + + + def pc_relators(self): + """ + Return the polycyclic presentation. + + There are two types of relations used in polycyclic + presentation. + i) Power relations of the form `x{i}^re{i} = R{i}{i}`, + `for 0 <= i < length(pcgs)` where `x` represents polycyclic + generator and `re` is the corresponding relative order. + + ii) Conjugate relations of the form `x{j}^-1*x{i}*x{j}`, + `for 0 <= j < i <= length(pcgs)`. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> from sympy.combinatorics.permutations import Permutation + >>> S = SymmetricGroup(49).sylow_subgroup(7) + >>> der = S.derived_series() + >>> G = der[len(der)-2] + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> pcgs = PcGroup.pcgs + >>> len(pcgs) + 6 + >>> free_group = collector.free_group + >>> pc_resentation = collector.pc_presentation + >>> free_to_perm = {} + >>> for s, g in zip(free_group.symbols, pcgs): + ... free_to_perm[s] = g + + >>> for k, v in pc_resentation.items(): + ... k_array = k.array_form + ... if v != (): + ... v_array = v.array_form + ... lhs = Permutation() + ... for gen in k_array: + ... s = gen[0] + ... e = gen[1] + ... lhs = lhs*free_to_perm[s]**e + ... if v == (): + ... assert lhs.is_identity + ... continue + ... rhs = Permutation() + ... for gen in v_array: + ... s = gen[0] + ... e = gen[1] + ... rhs = rhs*free_to_perm[s]**e + ... assert lhs == rhs + + """ + free_group = self.free_group + rel_order = self.relative_order + pc_relators = {} + perm_to_free = {} + pcgs = self.pcgs + + for gen, s in zip(pcgs, free_group.generators): + perm_to_free[gen**-1] = s**-1 + perm_to_free[gen] = s + + pcgs = pcgs[::-1] + series = self.pc_series[::-1] + rel_order = rel_order[::-1] + collected_gens = [] + + for i, gen in enumerate(pcgs): + re = rel_order[i] + relation = perm_to_free[gen]**re + G = series[i] + + l = G.generator_product(gen**re, original = True) + l.reverse() + + word = free_group.identity + for g in l: + word = word*perm_to_free[g] + + word = self.collected_word(word) + pc_relators[relation] = word if word else () + self.pc_presentation = pc_relators + + collected_gens.append(gen) + if len(collected_gens) > 1: + conj = collected_gens[len(collected_gens)-1] + conjugator = perm_to_free[conj] + + for j in range(len(collected_gens)-1): + conjugated = perm_to_free[collected_gens[j]] + + relation = conjugator**-1*conjugated*conjugator + gens = conj**-1*collected_gens[j]*conj + + l = G.generator_product(gens, original = True) + l.reverse() + word = free_group.identity + for g in l: + word = word*perm_to_free[g] + + word = self.collected_word(word) + pc_relators[relation] = word if word else () + self.pc_presentation = pc_relators + + return pc_relators + + def exponent_vector(self, element): + """ + Return the exponent vector of length equal to the + length of polycyclic generating sequence. + + For a given generator/element `g` of the polycyclic group, + it can be represented as `g = x{1}**e{1}....x{n}**e{n}`, + where `x{i}` represents polycyclic generators and `n` is + the number of generators in the free_group equal to the length + of pcgs. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> from sympy.combinatorics.permutations import Permutation + >>> G = SymmetricGroup(4) + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> pcgs = PcGroup.pcgs + >>> collector.exponent_vector(G[0]) + [1, 0, 0, 0] + >>> exp = collector.exponent_vector(G[1]) + >>> g = Permutation() + >>> for i in range(len(exp)): + ... g = g*pcgs[i]**exp[i] if exp[i] else g + >>> assert g == G[1] + + References + ========== + + .. [1] Holt, D., Eick, B., O'Brien, E. + "Handbook of Computational Group Theory" + Section 8.1.1, Definition 8.4 + + """ + free_group = self.free_group + G = PermutationGroup() + for g in self.pcgs: + G = PermutationGroup([g] + G.generators) + gens = G.generator_product(element, original = True) + gens.reverse() + + perm_to_free = {} + for sym, g in zip(free_group.generators, self.pcgs): + perm_to_free[g**-1] = sym**-1 + perm_to_free[g] = sym + w = free_group.identity + for g in gens: + w = w*perm_to_free[g] + + pc_presentation = self.pc_presentation + word = self.collected_word(w) + + index = self.index + exp_vector = [0]*len(free_group) + word = word.array_form + for t in word: + exp_vector[index[t[0]]] = t[1] + return exp_vector + + def depth(self, element): + """ + Return the depth of a given element. + + The depth of a given element `g` is defined by + `dep{g} = i if e{1} = e{2} = ... = e{i-1} = 0` + and `e{i} != 0`, where `e` represents the exponent-vector. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> G = SymmetricGroup(3) + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> collector.depth(G[0]) + 2 + >>> collector.depth(G[1]) + 1 + + References + ========== + + .. [1] Holt, D., Eick, B., O'Brien, E. + "Handbook of Computational Group Theory" + Section 8.1.1, Definition 8.5 + + """ + exp_vector = self.exponent_vector(element) + return next((i+1 for i, x in enumerate(exp_vector) if x), len(self.pcgs)+1) + + def leading_exponent(self, element): + """ + Return the leading non-zero exponent. + + The leading exponent for a given element `g` is defined + by `leading_exponent{g} = e{i}`, if `depth{g} = i`. + + Examples + ======== + >>> from sympy.combinatorics.named_groups import SymmetricGroup + >>> G = SymmetricGroup(3) + >>> PcGroup = G.polycyclic_group() + >>> collector = PcGroup.collector + >>> collector.leading_exponent(G[1]) + 1 + + """ + exp_vector = self.exponent_vector(element) + depth = self.depth(element) + if depth != len(self.pcgs)+1: + return exp_vector[depth-1] + return None diff --git a/sympy/combinatorics/perm_groups.py b/sympy/combinatorics/perm_groups.py index f3f84344db0d..f4e988c7e103 100644 --- a/sympy/combinatorics/perm_groups.py +++ b/sympy/combinatorics/perm_groups.py @@ -4515,6 +4515,32 @@ def _factor_group_by_rels(G, rels): G._fp_presentation = simplify_presentation(G_p) return G._fp_presentation + def polycyclic_group(self): + from sympy.combinatorics.pc_groups import PolycyclicGroup + if not self.is_polycyclic: + raise ValueError("The group must be solvable") + + der = self.derived_series() + pc_series = [] + pc_sequence = [] + relative_order = [] + pc_series.append(der[-1]) + der.reverse() + + for i in range(len(der)-1): + H = der[i] + for g in der[i+1].generators: + if g not in H: + H = PermutationGroup([g] + H.generators) + pc_series.insert(0, H) + pc_sequence.insert(0, g) + + G1 = pc_series[0].order() + G2 = pc_series[1].order() + relative_order.insert(0, G1 // G2) + + return PolycyclicGroup(pc_sequence, pc_series, relative_order, collector=None) + def _orbit(degree, generators, alpha, action='tuples'): r"""Compute the orbit of alpha `\{g(\alpha) | g \in G\}` as a set.

diff --git a/sympy/combinatorics/tests/test_pc_groups.py b/sympy/combinatorics/tests/test_pc_groups.py new file mode 100644 index 000000000000..ff4b9e7dad55 --- /dev/null +++ b/sympy/combinatorics/tests/test_pc_groups.py @@ -0,0 +1,72 @@ +from sympy.combinatorics.pc_groups import PolycyclicGroup, Collector +from sympy.combinatorics.permutations import Permutation +from sympy.combinatorics.named_groups import SymmetricGroup + +def test_pc_presentation(): + Groups = [SymmetricGroup(3), SymmetricGroup(4), SymmetricGroup(9).sylow_subgroup(3), + SymmetricGroup(9).sylow_subgroup(2), SymmetricGroup(8).sylow_subgroup(2)] + + S = SymmetricGroup(125).sylow_subgroup(5) + G = S.derived_series()[2] + Groups.append(G) + + G = SymmetricGroup(25).sylow_subgroup(5) + Groups.append(G) + + S = SymmetricGroup(11**2).sylow_subgroup(11) + G = S.derived_series()[2] + Groups.append(G) + + for G in Groups: + PcGroup = G.polycyclic_group() + collector = PcGroup.collector + pc_presentation = collector.pc_presentation + + pcgs = PcGroup.pcgs + free_group = collector.free_group + free_to_perm = {} + for s, g in zip(free_group.symbols, pcgs): + free_to_perm[s] = g + + for k, v in pc_presentation.items(): + k_array = k.array_form + if v != (): + v_array = v.array_form + + lhs = Permutation() + for gen in k_array: + s = gen[0] + e = gen[1] + lhs = lhs*free_to_perm[s]**e + + if v == (): + assert lhs.is_identity + continue + + rhs = Permutation() + for gen in v_array: + s = gen[0] + e = gen[1] + rhs = rhs*free_to_perm[s]**e + + assert lhs == rhs + + +def test_exponent_vector(): + + Groups = [SymmetricGroup(3), SymmetricGroup(4), SymmetricGroup(9).sylow_subgroup(3), + SymmetricGroup(9).sylow_subgroup(2), SymmetricGroup(8).sylow_subgroup(2)] + + for G in Groups: + PcGroup = G.polycyclic_group() + collector = PcGroup.collector + + pcgs = PcGroup.pcgs + free_group = collector.free_group + + for gen in G.generators: + exp = collector.exponent_vector(gen) + g = Permutation() + for i in range(len(exp)): + g = g*pcgs[i]**exp[i] if exp[i] else g + assert g == gen

diff --git a/doc/src/modules/combinatorics/index.rst b/doc/src/modules/combinatorics/index.rst index f753a41ae16a..2d70a46a13ee 100644 --- a/doc/src/modules/combinatorics/index.rst +++ b/doc/src/modules/combinatorics/index.rst @@ -23,3 +23,4 @@ Contents testutil.rst tensor_can.rst fp_groups.rst + pc_groups.rst diff --git a/doc/src/modules/combinatorics/pc_groups.rst b/doc/src/modules/combinatorics/pc_groups.rst new file mode 100644 index 000000000000..4114bbebebfd --- /dev/null +++ b/doc/src/modules/combinatorics/pc_groups.rst @@ -0,0 +1,12 @@ +.. _combinatorics-pc_groups: + +Polycyclic Groups +================= + +.. module:: sympy.combinatorics.pc_groups + +.. autoclass:: PolycyclicGroup + :members: + +.. autoclass:: Collector + :members: \ No newline at end of file

[ { "components": [ { "doc": "", "lines": [ 7, 22 ], "name": "PolycyclicGroup", "signature": "class PolycyclicGroup(DefaultPrinting):", "type": "class" }, { "doc": "", "lines": [ 12, 16 ...

[ "test_pc_presentation" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added Polycyclic Group Class   #### Brief description of what is fixed or changed Polycyclic group class has been added and few of the helper methods are also implemented. #### Other comments #### Release Notes   * combinatorics * added polycyclic group class and methods  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/combinatorics/pc_groups.py] (definition of PolycyclicGroup:) class PolycyclicGroup(DefaultPrinting): (definition of PolycyclicGroup.__init__:) def __init__(self, pc_sequence, pc_series, relative_order, collector=None): (definition of PolycyclicGroup.is_prime_order:) def is_prime_order(self): (definition of PolycyclicGroup.length:) def length(self): (definition of Collector:) class Collector(DefaultPrinting): """References ========== .. [1] Holt, D., Eick, B., O'Brien, E. "Handbook of Computational Group Theory" Section 8.1.3""" (definition of Collector.__init__:) def __init__(self, pcgs, pc_series, relative_order, group=None, pc_presentation=None): (definition of Collector.minimal_uncollected_subword:) def minimal_uncollected_subword(self, word): """Returns the minimal uncollected subwords. A word `v` defined on generators in `X` is a minimal uncollected subword of the word `w` if `v` is a subword of `w` and it has one of the following form i) `v = x[i+1]**a_j*x[i]` ii) `v = x[i+1]**a_j*x[i]**-1` iii) `v = x[i]**a_j` for relative_order of `x[i] != infinity` and `a_j` is not in `{1, ..., s-1}`. Where, s is the power exponent of the corresponding generator. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> from sympy.combinatorics.free_groups import free_group >>> G = SymmetricGroup(4) >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> F, x1, x2 = free_group("x1, x2") >>> word = x2**2*x1**7 >>> collector.minimal_uncollected_subword(word) ((x2, 2),)""" (definition of Collector.relations:) def relations(self): """Separates the given relators of pc presentation in power and conjugate relations. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> G = SymmetricGroup(3) >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> power_rel, conj_rel = collector.relations() >>> power_rel {x0**2: (), x1**3: ()} >>> conj_rel {x0**-1*x1*x0: x1**2}""" (definition of Collector.subword_index:) def subword_index(self, word, w): """Returns the start and ending index of a given subword in a word. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> from sympy.combinatorics.free_groups import free_group >>> G = SymmetricGroup(4) >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> F, x1, x2 = free_group("x1, x2") >>> word = x2**2*x1**7 >>> w = x2**2*x1 >>> collector.subword_index(word, w) (0, 3) >>> w = x1**7 >>> collector.subword_index(word, w) (2, 9)""" (definition of Collector.map_relation:) def map_relation(self, w): """Return a conjugate relation. Given a word formed by two free group elements, the corresponding conjugate relation with those free group elements is formed and mapped with the collected word in the polycyclic presentation. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> from sympy.combinatorics.free_groups import free_group >>> G = SymmetricGroup(3) >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> F, x0, x1 = free_group("x0, x1") >>> w = x1*x0 >>> collector.map_relation(w) x1**2""" (definition of Collector.collected_word:) def collected_word(self, word): """Return the collected form of a word. A word `w` is called collected, if `w = x{i_1}**a_1*...*x{i_r}**a_r` with `i_1 < i_2< ... < i_r` and `a_j` is in `{1, ..., s_j-1}` if `s_j != infinity`. Otherwise w is uncollected. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> from sympy.combinatorics.perm_groups import PermutationGroup >>> from sympy.combinatorics.free_groups import free_group >>> G = SymmetricGroup(4) >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> F, x0, x1, x2, x3 = free_group("x0, x1, x2, x3") >>> word = x3*x2*x1*x0 >>> collected_word = collector.collected_word(word) >>> free_to_perm = {} >>> free_group = collector.free_group >>> for sym, gen in zip(free_group.symbols, collector.pcgs): ... free_to_perm[sym] = gen >>> G1 = PermutationGroup() >>> for w in word: ... sym = w[0] ... perm = free_to_perm[sym] ... G1 = PermutationGroup([perm] + G1.generators) >>> G2 = PermutationGroup() >>> for w in collected_word: ... sym = w[0] ... perm = free_to_perm[sym] ... G2 = PermutationGroup([perm] + G2.generators) >>> G1 == G2 True""" (definition of Collector.pc_relators:) def pc_relators(self): """Return the polycyclic presentation. There are two types of relations used in polycyclic presentation. i) Power relations of the form `x{i}^re{i} = R{i}{i}`, `for 0 <= i < length(pcgs)` where `x` represents polycyclic generator and `re` is the corresponding relative order. ii) Conjugate relations of the form `x{j}^-1*x{i}*x{j}`, `for 0 <= j < i <= length(pcgs)`. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> from sympy.combinatorics.permutations import Permutation >>> S = SymmetricGroup(49).sylow_subgroup(7) >>> der = S.derived_series() >>> G = der[len(der)-2] >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> pcgs = PcGroup.pcgs >>> len(pcgs) 6 >>> free_group = collector.free_group >>> pc_resentation = collector.pc_presentation >>> free_to_perm = {} >>> for s, g in zip(free_group.symbols, pcgs): ... free_to_perm[s] = g >>> for k, v in pc_resentation.items(): ... k_array = k.array_form ... if v != (): ... v_array = v.array_form ... lhs = Permutation() ... for gen in k_array: ... s = gen[0] ... e = gen[1] ... lhs = lhs*free_to_perm[s]**e ... if v == (): ... assert lhs.is_identity ... continue ... rhs = Permutation() ... for gen in v_array: ... s = gen[0] ... e = gen[1] ... rhs = rhs*free_to_perm[s]**e ... assert lhs == rhs""" (definition of Collector.exponent_vector:) def exponent_vector(self, element): """Return the exponent vector of length equal to the length of polycyclic generating sequence. For a given generator/element `g` of the polycyclic group, it can be represented as `g = x{1}**e{1}....x{n}**e{n}`, where `x{i}` represents polycyclic generators and `n` is the number of generators in the free_group equal to the length of pcgs. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> from sympy.combinatorics.permutations import Permutation >>> G = SymmetricGroup(4) >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> pcgs = PcGroup.pcgs >>> collector.exponent_vector(G[0]) [1, 0, 0, 0] >>> exp = collector.exponent_vector(G[1]) >>> g = Permutation() >>> for i in range(len(exp)): ... g = g*pcgs[i]**exp[i] if exp[i] else g >>> assert g == G[1] References ========== .. [1] Holt, D., Eick, B., O'Brien, E. "Handbook of Computational Group Theory" Section 8.1.1, Definition 8.4""" (definition of Collector.depth:) def depth(self, element): """Return the depth of a given element. The depth of a given element `g` is defined by `dep{g} = i if e{1} = e{2} = ... = e{i-1} = 0` and `e{i} != 0`, where `e` represents the exponent-vector. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> G = SymmetricGroup(3) >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> collector.depth(G[0]) 2 >>> collector.depth(G[1]) 1 References ========== .. [1] Holt, D., Eick, B., O'Brien, E. "Handbook of Computational Group Theory" Section 8.1.1, Definition 8.5""" (definition of Collector.leading_exponent:) def leading_exponent(self, element): """Return the leading non-zero exponent. The leading exponent for a given element `g` is defined by `leading_exponent{g} = e{i}`, if `depth{g} = i`. Examples ======== >>> from sympy.combinatorics.named_groups import SymmetricGroup >>> G = SymmetricGroup(3) >>> PcGroup = G.polycyclic_group() >>> collector = PcGroup.collector >>> collector.leading_exponent(G[1]) 1""" [end of new definitions in sympy/combinatorics/pc_groups.py] [start of new definitions in sympy/combinatorics/perm_groups.py] (definition of PermutationGroup.polycyclic_group:) def polycyclic_group(self): [end of new definitions in sympy/combinatorics/perm_groups.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-16981

16,981

sympy/sympy

1.5

9576ee3c04cd779524efbf4fe67f1e0658ad93d1

2019-06-06T14:51:24Z

diff --git a/sympy/stats/__init__.py b/sympy/stats/__init__.py index ee5889933ebe..cf0037cab1d7 100644 --- a/sympy/stats/__init__.py +++ b/sympy/stats/__init__.py @@ -80,6 +80,16 @@ ) __all__.extend(joint_rv_types.__all__) +from . import stochastic_process_types +from .stochastic_process_types import ( + StochasticProcess, + DiscreteTimeStochasticProcess, + DiscreteMarkovChain, + TransitionMatrixOf, + StochasticStateSpaceOf +) +__all__.extend(stochastic_process_types.__all__) + from . import symbolic_probability from .symbolic_probability import Probability, Expectation, Variance, Covariance __all__.extend(symbolic_probability.__all__) diff --git a/sympy/stats/rv.py b/sympy/stats/rv.py index c5872bd200a4..353a13974f9d 100644 --- a/sympy/stats/rv.py +++ b/sympy/stats/rv.py @@ -17,7 +17,7 @@ from sympy import (Basic, S, Expr, Symbol, Tuple, And, Add, Eq, lambdify, Equality, Lambda, sympify, Dummy, Ne, KroneckerDelta, - DiracDelta, Mul) + DiracDelta, Mul, Indexed) from sympy.core.compatibility import string_types from sympy.core.relational import Relational from sympy.logic.boolalg import Boolean @@ -268,13 +268,20 @@ def _eval_is_real(self): def is_commutative(self): return self.symbol.is_commutative - def _hashable_content(self): - return self.pspace, self.symbol - @property def free_symbols(self): return {self} +class RandomIndexedSymbol(RandomSymbol): + + def __new__(cls, idx_obj, pspace=None): + if not isinstance(idx_obj, Indexed): + raise TypeError("An indexed object is expected not %s"%(idx_obj)) + return Basic.__new__(cls, idx_obj, pspace) + + symbol = property(lambda self: self.args[0]) + name = symbol + key = property(lambda self: self.symbol.args[1]) class ProductPSpace(PSpace): """ @@ -729,6 +736,9 @@ def probability(condition, given_condition=None, numsamples=None, condition = sympify(condition) given_condition = sympify(given_condition) + if condition.has(RandomIndexedSymbol): + return pspace(condition).probability(condition, given_condition, **kwargs) + if isinstance(given_condition, RandomSymbol): condrv = random_symbols(condition) if len(condrv) == 1 and condrv[0] == given_condition: @@ -1385,3 +1395,49 @@ def _value_check(condition, message): if truth == False: raise ValueError(message) return truth == True + +def _symbol_converter(sym): + """ + Casts the parameter to Symbol if it is of string_types + otherwise no operation is performed on it. + + Parameters + ========== + + sym + The parameter to be converted. + + Returns + ======= + + Symbol + the parameter converted to Symbol. + + Raises + ====== + + TypeError + If the parameter is not an instance of both string_types and + Symbol. + + Examples + ======== + + >>> from sympy import Symbol + >>> from sympy.stats.rv import _symbol_converter + >>> s = _symbol_converter('s') + >>> isinstance(s, Symbol) + True + >>> _symbol_converter(1) + Traceback (most recent call last): + ... + TypeError: 1 is neither a Symbol nor a string + >>> r = Symbol('r') + >>> isinstance(r, Symbol) + True + """ + if isinstance(sym, string_types): + sym = Symbol(sym) + if not isinstance(sym, Symbol): + raise TypeError("%s is neither a Symbol nor a string"%(sym)) + return sym diff --git a/sympy/stats/stochastic_process.py b/sympy/stats/stochastic_process.py new file mode 100644 index 000000000000..4520830e1f31 --- /dev/null +++ b/sympy/stats/stochastic_process.py @@ -0,0 +1,77 @@ +from __future__ import print_function, division + +from sympy import Basic, Symbol +from sympy.core.compatibility import string_types +from sympy.stats.rv import ProductDomain +from sympy.stats.joint_rv import ProductPSpace, JointRandomSymbol + +class StochasticPSpace(ProductPSpace): + """ + Represents probability space of stochastic processes + and their random variables. Contains mechanics to do + computations for queries of stochastic processes. + + Initialized by symbol and the specific process. + """ + + def __new__(cls, sym, process): + if isinstance(sym, string_types): + sym = Symbol(sym) + if not isinstance(sym, Symbol): + raise TypeError("Name of stochastic process should be either only " + "a string or Symbol.") + from sympy.stats.stochastic_process_types import StochasticProcess + if not isinstance(process, StochasticProcess): + raise TypeError("`process` must be an instance of StochasticProcess.") + return Basic.__new__(cls, sym, process) + + @property + def process(self): + """ + The associated stochastic process. + """ + return self.args[1] + + @property + def domain(self): + return ProductDomain(self.process.index_set, + self.process.state_space) + + @property + def symbol(self): + return self.args[0] + + def probability(self, condition, given_condition=None, **kwargs): + """ + Transfers the task of handling queries to the specific stochastic + process because every process has their own logic of handling such + queries. + """ + return self.process.probability(condition, given_condition, **kwargs) + + def joint_distribution(self, *args): + """ + Computes the joint distribution of the random indexed variables. + + Parameters + ========== + + args: iterable + The finite list of random indexed variables of a stochastic + process whose joint distribution has to be computed. + + Returns + ======= + + JointDistribution + The joint distribution of the list of random indexed variables. + An unevaluated object is returned if it is not possible to + compute the joint distribution. + + Raises + ====== + + ValueError: When the time/key of random indexed variables + is not in strictly increasing order. + """ + NotImplementedError() diff --git a/sympy/stats/stochastic_process_types.py b/sympy/stats/stochastic_process_types.py new file mode 100644 index 000000000000..d6eefdc066fb --- /dev/null +++ b/sympy/stats/stochastic_process_types.py @@ -0,0 +1,314 @@ +from sympy import (Symbol, Matrix, MatrixSymbol, S, Indexed, Basic, + Set, And, Tuple, Eq, FiniteSet, ImmutableMatrix, + nsimplify) +from sympy.stats.rv import (RandomIndexedSymbol, random_symbols, RandomSymbol, + _symbol_converter) +from sympy.core.compatibility import string_types +from sympy.core.relational import Relational +from sympy.stats.symbolic_probability import Probability +from sympy.stats.stochastic_process import StochasticPSpace +from sympy.logic.boolalg import Boolean + +__all__ = [ + 'StochasticProcess', + 'DiscreteTimeStochasticProcess', + 'DiscreteMarkovChain', + 'TransitionMatrixOf', + 'StochasticStateSpaceOf' +] + +def _set_converter(itr): + """ + Helper function for converting list/tuple/set to Set. + If parameter is not an instance of list/tuple/set then + no operation is performed. + + Returns + ======= + + Set + The argument converted to Set. + + + Raises + ====== + + TypeError + If the argument is not an instance of list/tuple/set. + """ + if isinstance(itr, (list, tuple, set)): + itr = FiniteSet(*itr) + if not isinstance(itr, Set): + raise TypeError("%s is not an instance of list/tuple/set."%(itr)) + return itr + +def _matrix_checks(matrix): + if not isinstance(matrix, (Matrix, MatrixSymbol, ImmutableMatrix)): + raise TypeError("Transition probabilities etiher should " + "be a Matrix or a MatrixSymbol.") + if matrix.shape[0] != matrix.shape[1]: + raise ValueError("%s is not a square matrix"%(matrix)) + if isinstance(matrix, Matrix): + matrix = ImmutableMatrix(matrix.tolist()) + return matrix + +class StochasticProcess(Basic): + """ + Base class for all the stochastic processes whether + discrete or continuous. + + Parameters + ========== + + sym: Symbol or string_types + state_space: Set + The state space of the stochastic process, by default S.Reals. + For discrete sets it is zero indexed. + + See Also + ======== + + DiscreteTimeStochasticProcess + """ + + def __new__(cls, sym, state_space=S.Reals): + sym = _symbol_converter(sym) + state_space = _set_converter(state_space) + return Basic.__new__(cls, sym, state_space) + + @property + def symbol(self): + return self.args[0] + + @property + def state_space(self): + return self.args[1] + + def __call__(self, time): + """ + Overrided in ContinuousTimeStochasticProcess. + """ + raise NotImplementedError("Use [] for indexing discrete time stochastic process.") + + def __getitem__(self, time): + """ + Overrided in DiscreteTimeStochasticProcess. + """ + raise NotImplementedError("Use () for indexing continuous time stochastic process.") + + def probability(self, condition): + raise NotImplementedError() + +class DiscreteTimeStochasticProcess(StochasticProcess): + """ + Base class for all discrete stochastic processes. + """ + def __getitem__(self, time): + """ + For indexing discrete time stochastic processes. + + Returns + ======= + + RandomIndexedSymbol + """ + if time not in self.index_set: + raise IndexError("%s is not in the index set of %s"%(time, self.symbol)) + idx_obj = Indexed(self.symbol, time) + pspace_obj = StochasticPSpace(self.symbol, self) + return RandomIndexedSymbol(idx_obj, pspace_obj) + +class TransitionMatrixOf(Boolean): + """ + Assumes that the matrix is the transition matrix + of the process. + """ + + def __new__(cls, process, matrix): + if not isinstance(process, DiscreteMarkovChain): + raise ValueError("Currently only DiscreteMarkovChain " + "support TransitionMatrixOf.") + matrix = _matrix_checks(matrix) + return Basic.__new__(cls, process, matrix) + + process = property(lambda self: self.args[0]) + matrix = property(lambda self: self.args[1]) + +class StochasticStateSpaceOf(Boolean): + + def __new__(cls, process, state_space): + if not isinstance(process, DiscreteMarkovChain): + raise ValueError("Currently only DiscreteMarkovChain " + "support StochasticStateSpaceOf.") + state_space = _set_converter(state_space) + return Basic.__new__(cls, process, state_space) + + process = property(lambda self: self.args[0]) + state_space = property(lambda self: self.args[1]) + +class DiscreteMarkovChain(DiscreteTimeStochasticProcess): + """ + Represents discrete Markov chain. + + Parameters + ========== + + sym: Symbol + state_space: Set + Optional, by default, S.Reals + trans_probs: Matrix/ImmutableMatrix/MatrixSymbol + Optional, by default, None + + Examples + ======== + + >>> from sympy.stats import DiscreteMarkovChain, TransitionMatrixOf + >>> from sympy import Matrix, MatrixSymbol, Eq + >>> from sympy.stats import P + >>> T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]]) + >>> Y = DiscreteMarkovChain("Y", [0, 1, 2], T) + >>> YS = DiscreteMarkovChain("Y") + >>> Y.state_space + {0, 1, 2} + >>> Y.transition_probabilities + Matrix([ + [0.5, 0.2, 0.3], + [0.2, 0.5, 0.3], + [0.2, 0.3, 0.5]]) + >>> TS = MatrixSymbol('T', 3, 3) + >>> P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TS)) + T[0, 2]*T[1, 0] + T[1, 1]*T[1, 2] + T[1, 2]*T[2, 2] + >>> P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) + 0.36 + """ + + index_set = S.Naturals0 + + def __new__(cls, sym, state_space=S.Reals, trans_probs=None): + sym = _symbol_converter(sym) + state_space = _set_converter(state_space) + if trans_probs != None: + trans_probs = _matrix_checks(trans_probs) + return Basic.__new__(cls, sym, state_space, trans_probs) + + @property + def transition_probabilities(self): + """ + Transition probabilities of discrete Markov chain, + either an instance of Matrix or MatrixSymbol. + """ + return self.args[2] + + def probability(self, condition, given_condition, **kwargs): + """ + Handles probability queries for discrete Markov chains. + + Parameters + ========== + + condition: Relational + given_condition: Relational/And + + Returns + ======= + + Probability + If the transition probabilities are not available + Expr + If the transition probabilities is MatrixSymbol or Matrix + + Note + ==== + + Any information passed at the time of query overrides + any information passed at the time of object creation like + transition probabilities, state space. + + Pass the transition matrix using TransitionMatrixOf and state space + using StochasticStateSpaceOf in given_condition using & or And. + """ + + # extracting transition matrix and state space + trans_probs, state_space = self.transition_probabilities, self.state_space + if isinstance(given_condition, And): + gcs = given_condition.args + for gc in gcs: + if isinstance(gc, TransitionMatrixOf): + trans_probs = gc.matrix + if isinstance(gc, StochasticStateSpaceOf): + state_space = gc.state_space + if isinstance(gc, Eq): + given_condition = gc + if isinstance(given_condition, TransitionMatrixOf): + trans_probs = given_condition.matrix + if isinstance(given_condition, StochasticStateSpaceOf): + state_space = given_condition.state_space + + # given_condition does not have sufficient information + # for computations + if trans_probs == None or \ + given_condition == None: + return Probability(condition, given_condition, **kwargs) + + # working out transition probabilities + if not isinstance(trans_probs, MatrixSymbol): + rows = trans_probs.tolist() + for row in rows: + if (sum(row) - 1) != 0: + raise ValueError("Probabilities in a row must sum to 1. " + "If you are using Float or floats then please use Rational.") + + # if given condition is None, then there is no need to work out + # state_space from random variables + if given_condition != None: + rand_var = list(given_condition.atoms(RandomSymbol) - + given_condition.atoms(RandomIndexedSymbol)) + if len(rand_var) == 1: + state_space = rand_var[0].pspace.set + if not FiniteSet(*[i for i in range(trans_probs.shape[0])]).is_subset(state_space): + raise ValueError("state space is not compatible with the transition probabilites.") + + if isinstance(condition, Eq) and \ + isinstance(given_condition, Eq) and \ + len(given_condition.atoms(RandomSymbol)) == 1: + # handles simple queries like P(Eq(X[i], dest_state), Eq(X[i], init_state)) + lhsc, rhsc = condition.lhs, condition.rhs + lhsg, rhsg = given_condition.lhs, given_condition.rhs + if not isinstance(lhsc, RandomIndexedSymbol): + lhsc, rhsc = (rhsc, lhsc) + if not isinstance(lhsg, RandomIndexedSymbol): + lhsg, rhsg = (rhsg, lhsg) + keyc, statec, keyg, stateg = (lhsc.key, rhsc, lhsg.key, rhsg) + if stateg >= trans_probs.shape[0] == False or statec >= trans_probs.shape[1]: + raise IndexError("No information is avaliable for (%s, %s) in " + "transition probabilities of shape, (%s, %s). " + "State space is zero indexed." + %(stateg, statec, trans_probs.shape[0], trans_probs.shape[1])) + if keyc < keyg: + raise ValueError("Incorrect given condition is given, probability " + "of past state cannot be computed from future state.") + nsteptp = trans_probs**(keyc - keyg) + if hasattr(nsteptp, "__getitem__"): + return nsteptp.__getitem__((stateg, statec)) + return Indexed(nsteptp, stateg, statec) + + if isinstance(condition, And): + # handle queries like, + # P(Eq(X[i+k], s1) & Eq(X[i+m], s2) . . . & Eq(X[i], sn), Eq(P(X[i]), prob)) + conds = condition.args + i, result = -1, 1 + while i > -len(conds): + result *= self.probability(conds[i], conds[i-1] & \ + TransitionMatrixOf(self, trans_probs) & \ + StochasticStateSpaceOf(self, state_space)) + i -= 1 + if isinstance(given_condition, (TransitionMatrixOf, StochasticStateSpaceOf)): + return result * Probability(conds[i]) + if isinstance(given_condition, Eq): + if not isinstance(given_condition.lhs, Probability) or \ + given_condition.lhs.args[0] != conds[i]: + raise ValueError("Probability for %s needed", conds[i]) + return result * given_condition.rhs + + raise NotImplementedError("Mechanism for handling (%s, %s) queries hasn't been " + "implemented yet."%(condition, given_condition))

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index b4912d134d17..c123936675c6 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1530,6 +1530,43 @@ def test_sympy__stats__joint_rv_types__NegativeMultinomialDistribution(): from sympy.stats.joint_rv_types import NegativeMultinomialDistribution assert _test_args(NegativeMultinomialDistribution(5, [0.5, 0.1, 0.3])) +def test_sympy__stats__rv__RandomIndexedSymbol(): + from sympy.stats.rv import RandomIndexedSymbol, pspace + from sympy.tensor import Indexed + from sympy.stats.stochastic_process_types import DiscreteMarkovChain + X = DiscreteMarkovChain("X") + assert _test_args(RandomIndexedSymbol(X[0].symbol, pspace(X[0]))) + +def test_sympy__stats__stochastic_process__StochasticPSpace(): + from sympy.stats.stochastic_process import StochasticPSpace + from sympy.stats.stochastic_process_types import StochasticProcess + assert _test_args(StochasticPSpace("Y", StochasticProcess("Y", [1, 2, 3]))) + +def test_sympy__stats__stochastic_process_types__StochasticProcess(): + from sympy.stats.stochastic_process_types import StochasticProcess + assert _test_args(StochasticProcess("Y", [1, 2, 3])) + +def test_sympy__stats__stochastic_process_types__DiscreteTimeStochasticProcess(): + from sympy.stats.stochastic_process_types import DiscreteTimeStochasticProcess + assert _test_args(DiscreteTimeStochasticProcess("Y", [1, 2, 3])) + +def test_sympy__stats__stochastic_process_types__TransitionMatrixOf(): + from sympy.stats.stochastic_process_types import TransitionMatrixOf, DiscreteMarkovChain + from sympy import MatrixSymbol + DMC = DiscreteMarkovChain("Y") + assert _test_args(TransitionMatrixOf(DMC, MatrixSymbol('T', 3, 3))) + +def test_sympy__stats__stochastic_process_types__StochasticStateSpaceOf(): + from sympy.stats.stochastic_process_types import StochasticStateSpaceOf, DiscreteMarkovChain + from sympy import MatrixSymbol + DMC = DiscreteMarkovChain("Y") + assert _test_args(StochasticStateSpaceOf(DMC, [0, 1, 2])) + +def test_sympy__stats__stochastic_process_types__DiscreteMarkovChain(): + from sympy.stats.stochastic_process_types import DiscreteMarkovChain + from sympy import MatrixSymbol + assert _test_args(DiscreteMarkovChain("Y", [0, 1, 2], MatrixSymbol('T', 3, 3))) + def test_sympy__core__symbol__Dummy(): from sympy.core.symbol import Dummy assert _test_args(Dummy('t')) diff --git a/sympy/stats/tests/test_stochastic_process.py b/sympy/stats/tests/test_stochastic_process.py new file mode 100644 index 000000000000..cd974e42afb0 --- /dev/null +++ b/sympy/stats/tests/test_stochastic_process.py @@ -0,0 +1,41 @@ +from sympy import (S, symbols, FiniteSet, Eq, Matrix, MatrixSymbol, Float, And) +from sympy.stats import DiscreteMarkovChain, P, TransitionMatrixOf +from sympy.stats.rv import RandomIndexedSymbol +from sympy.stats.symbolic_probability import Probability +from sympy.utilities.pytest import raises + +def test_DiscreteMarkovChain(): + + # pass only the name + X = DiscreteMarkovChain("X") + assert X.state_space == S.Reals + assert X.index_set == S.Naturals0 + assert X.transition_probabilities == None + t = symbols('t', positive=True, integer=True) + assert isinstance(X[t], RandomIndexedSymbol) + + # pass name and state_space + Y = DiscreteMarkovChain("Y", [1, 2, 3]) + assert Y.transition_probabilities == None + assert Y.state_space == FiniteSet(1, 2, 3) + assert P(Eq(Y[2], 1), Eq(Y[0], 2)) == Probability(Eq(Y[2], 1), Eq(Y[0], 2)) + + # pass name, state_space and transition_probabilities + T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]]) + TS = MatrixSymbol('T', 3, 3) + Y = DiscreteMarkovChain("Y", [0, 1, 2], T) + YS = DiscreteMarkovChain("Y", [0, 1, 2], TS) + assert P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) == Float(0.36, 2) + assert str(P(Eq(YS[3], 2), Eq(YS[1], 1))) == \ + "T[0, 2]*T[1, 0] + T[1, 1]*T[1, 2] + T[1, 2]*T[2, 2]" + TO = Matrix([[0.25, 0.75, 0],[0, 0.25, 0.75],[0.75, 0, 0.25]]) + assert P(Eq(Y[3], 2), Eq(Y[1], 1) & TransitionMatrixOf(Y, TO)).round(3) == Float(0.375, 3) + TSO = MatrixSymbol('T', 4, 4) + raises(ValueError, lambda: str(P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TSO)))) + + # extended tests for probability queries + TO1 = Matrix([[S(1)/4, S(3)/4, 0],[S(1)/3, S(1)/3, S(1)/3],[0, S(1)/4, S(3)/4]]) + assert P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)), + Eq(Probability(Eq(Y[0], 0)), S(1)/4) & TransitionMatrixOf(Y, TO1)) == S(1)/16 + assert P(And(Eq(Y[2], 1), Eq(Y[1], 1), Eq(Y[0], 0)), TransitionMatrixOf(Y, TO1)) == \ + Probability(Eq(Y[0], 0))/4

[ { "components": [ { "doc": "", "lines": [ 275, 284 ], "name": "RandomIndexedSymbol", "signature": "class RandomIndexedSymbol(RandomSymbol):", "type": "class" }, { "doc": "", "lines": [ 277, ...

[ "test_sympy__stats__rv__RandomIndexedSymbol", "test_sympy__stats__stochastic_process__StochasticPSpace", "test_sympy__stats__stochastic_process_types__StochasticProcess", "test_sympy__stats__stochastic_process_types__DiscreteTimeStochasticProcess", "test_sympy__stats__stochastic_process_types__TransitionMat...

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added StochasticProcess and DiscreteMarkovChain  #### References to other Issues or PRs  [1] https://github.com/sympy/sympy/issues/16895 #### Brief description of what is fixed or changed `StochasticPSpace` has been added to `sympy.stats.stochastic_process`, `StochasticProcess` and `DiscreteMarkovChain` has been added to `sympy.stats.stochastic_process_types`. Associated tests have also been added. Currently the `DiscreteMarkovChain` handles only probability queries More features, like expectation, joint_distribution will be done in other PRs so that it is easier to review. #### Other comments Following are the references for the additions, 1. **API** - https://github.com/sympy/sympy/issues/16895#issuecomment-497649797 2. **StochasticPSpace** - https://github.com/sympy/sympy/issues/16895#issuecomment-498039663 3. **RandomIndexedSymbol** - https://github.com/sympy/sympy/pull/16852#issuecomment-493765433, https://github.com/sympy/sympy/pull/16866/files#r286833831 #### Release Notes   * stats * `StochasticProcess` and `DiscreteMarkovChain` added to `sympy.stats`.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/rv.py] (definition of RandomIndexedSymbol:) class RandomIndexedSymbol(RandomSymbol): (definition of RandomIndexedSymbol.__new__:) def __new__(cls, idx_obj, pspace=None): (definition of _symbol_converter:) def _symbol_converter(sym): """Casts the parameter to Symbol if it is of string_types otherwise no operation is performed on it. Parameters ========== sym The parameter to be converted. Returns ======= Symbol the parameter converted to Symbol. Raises ====== TypeError If the parameter is not an instance of both string_types and Symbol. Examples ======== >>> from sympy import Symbol >>> from sympy.stats.rv import _symbol_converter >>> s = _symbol_converter('s') >>> isinstance(s, Symbol) True >>> _symbol_converter(1) Traceback (most recent call last): ... TypeError: 1 is neither a Symbol nor a string >>> r = Symbol('r') >>> isinstance(r, Symbol) True""" [end of new definitions in sympy/stats/rv.py] [start of new definitions in sympy/stats/stochastic_process.py] (definition of StochasticPSpace:) class StochasticPSpace(ProductPSpace): """Represents probability space of stochastic processes and their random variables. Contains mechanics to do computations for queries of stochastic processes. Initialized by symbol and the specific process.""" (definition of StochasticPSpace.__new__:) def __new__(cls, sym, process): (definition of StochasticPSpace.process:) def process(self): """The associated stochastic process.""" (definition of StochasticPSpace.domain:) def domain(self): (definition of StochasticPSpace.symbol:) def symbol(self): (definition of StochasticPSpace.probability:) def probability(self, condition, given_condition=None, **kwargs): """Transfers the task of handling queries to the specific stochastic process because every process has their own logic of handling such queries.""" (definition of StochasticPSpace.joint_distribution:) def joint_distribution(self, *args): """Computes the joint distribution of the random indexed variables. Parameters ========== args: iterable The finite list of random indexed variables of a stochastic process whose joint distribution has to be computed. Returns ======= JointDistribution The joint distribution of the list of random indexed variables. An unevaluated object is returned if it is not possible to compute the joint distribution. Raises ====== ValueError: When the time/key of random indexed variables is not in strictly increasing order.""" [end of new definitions in sympy/stats/stochastic_process.py] [start of new definitions in sympy/stats/stochastic_process_types.py] (definition of _set_converter:) def _set_converter(itr): """Helper function for converting list/tuple/set to Set. If parameter is not an instance of list/tuple/set then no operation is performed. Returns ======= Set The argument converted to Set. Raises ====== TypeError If the argument is not an instance of list/tuple/set.""" (definition of _matrix_checks:) def _matrix_checks(matrix): (definition of StochasticProcess:) class StochasticProcess(Basic): """Base class for all the stochastic processes whether discrete or continuous. Parameters ========== sym: Symbol or string_types state_space: Set The state space of the stochastic process, by default S.Reals. For discrete sets it is zero indexed. See Also ======== DiscreteTimeStochasticProcess""" (definition of StochasticProcess.__new__:) def __new__(cls, sym, state_space=S.Reals): (definition of StochasticProcess.symbol:) def symbol(self): (definition of StochasticProcess.state_space:) def state_space(self): (definition of StochasticProcess.__call__:) def __call__(self, time): """Overrided in ContinuousTimeStochasticProcess.""" (definition of StochasticProcess.__getitem__:) def __getitem__(self, time): """Overrided in DiscreteTimeStochasticProcess.""" (definition of StochasticProcess.probability:) def probability(self, condition): (definition of DiscreteTimeStochasticProcess:) class DiscreteTimeStochasticProcess(StochasticProcess): """Base class for all discrete stochastic processes.""" (definition of DiscreteTimeStochasticProcess.__getitem__:) def __getitem__(self, time): """For indexing discrete time stochastic processes. Returns ======= RandomIndexedSymbol""" (definition of TransitionMatrixOf:) class TransitionMatrixOf(Boolean): """Assumes that the matrix is the transition matrix of the process.""" (definition of TransitionMatrixOf.__new__:) def __new__(cls, process, matrix): (definition of StochasticStateSpaceOf:) class StochasticStateSpaceOf(Boolean): (definition of StochasticStateSpaceOf.__new__:) def __new__(cls, process, state_space): (definition of DiscreteMarkovChain:) class DiscreteMarkovChain(DiscreteTimeStochasticProcess): """Represents discrete Markov chain. Parameters ========== sym: Symbol state_space: Set Optional, by default, S.Reals trans_probs: Matrix/ImmutableMatrix/MatrixSymbol Optional, by default, None Examples ======== >>> from sympy.stats import DiscreteMarkovChain, TransitionMatrixOf >>> from sympy import Matrix, MatrixSymbol, Eq >>> from sympy.stats import P >>> T = Matrix([[0.5, 0.2, 0.3],[0.2, 0.5, 0.3],[0.2, 0.3, 0.5]]) >>> Y = DiscreteMarkovChain("Y", [0, 1, 2], T) >>> YS = DiscreteMarkovChain("Y") >>> Y.state_space {0, 1, 2} >>> Y.transition_probabilities Matrix([ [0.5, 0.2, 0.3], [0.2, 0.5, 0.3], [0.2, 0.3, 0.5]]) >>> TS = MatrixSymbol('T', 3, 3) >>> P(Eq(YS[3], 2), Eq(YS[1], 1) & TransitionMatrixOf(YS, TS)) T[0, 2]*T[1, 0] + T[1, 1]*T[1, 2] + T[1, 2]*T[2, 2] >>> P(Eq(Y[3], 2), Eq(Y[1], 1)).round(2) 0.36""" (definition of DiscreteMarkovChain.__new__:) def __new__(cls, sym, state_space=S.Reals, trans_probs=None): (definition of DiscreteMarkovChain.transition_probabilities:) def transition_probabilities(self): """Transition probabilities of discrete Markov chain, either an instance of Matrix or MatrixSymbol.""" (definition of DiscreteMarkovChain.probability:) def probability(self, condition, given_condition, **kwargs): """Handles probability queries for discrete Markov chains. Parameters ========== condition: Relational given_condition: Relational/And Returns ======= Probability If the transition probabilities are not available Expr If the transition probabilities is MatrixSymbol or Matrix Note ==== Any information passed at the time of query overrides any information passed at the time of object creation like transition probabilities, state space. Pass the transition matrix using TransitionMatrixOf and state space using StochasticStateSpaceOf in given_condition using & or And.""" [end of new definitions in sympy/stats/stochastic_process_types.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

dpkp__kafka-python-1833

1,833

dpkp/kafka-python

null

79dd508b14fd2d66a8b6d32353e8e64989c4ff84

2019-06-03T20:40:19Z

diff --git a/kafka/admin/__init__.py b/kafka/admin/__init__.py index a300301c6..c240fc6d0 100644 --- a/kafka/admin/__init__.py +++ b/kafka/admin/__init__.py @@ -2,9 +2,13 @@ from kafka.admin.config_resource import ConfigResource, ConfigResourceType from kafka.admin.client import KafkaAdminClient +from kafka.admin.acl_resource import (ACL, ACLFilter, ResourcePattern, ResourcePatternFilter, ACLOperation, + ResourceType, ACLPermissionType, ACLResourcePatternType) from kafka.admin.new_topic import NewTopic from kafka.admin.new_partitions import NewPartitions __all__ = [ - 'ConfigResource', 'ConfigResourceType', 'KafkaAdminClient', 'NewTopic', 'NewPartitions' + 'ConfigResource', 'ConfigResourceType', 'KafkaAdminClient', 'NewTopic', 'NewPartitions', 'ACL', 'ACLFilter', + 'ResourcePattern', 'ResourcePatternFilter', 'ACLOperation', 'ResourceType', 'ACLPermissionType', + 'ACLResourcePatternType' ] diff --git a/kafka/admin/acl_resource.py b/kafka/admin/acl_resource.py new file mode 100644 index 000000000..7a012d2fa --- /dev/null +++ b/kafka/admin/acl_resource.py @@ -0,0 +1,212 @@ +from __future__ import absolute_import +from kafka.errors import IllegalArgumentError + +# enum in stdlib as of py3.4 +try: + from enum import IntEnum # pylint: disable=import-error +except ImportError: + # vendored backport module + from kafka.vendor.enum34 import IntEnum + + +class ResourceType(IntEnum): + """Type of kafka resource to set ACL for + + The ANY value is only valid in a filter context + """ + + UNKNOWN = 0, + ANY = 1, + CLUSTER = 4, + DELEGATION_TOKEN = 6, + GROUP = 3, + TOPIC = 2, + TRANSACTIONAL_ID = 5 + + +class ACLOperation(IntEnum): + """Type of operation + + The ANY value is only valid in a filter context + """ + + ANY = 1, + ALL = 2, + READ = 3, + WRITE = 4, + CREATE = 5, + DELETE = 6, + ALTER = 7, + DESCRIBE = 8, + CLUSTER_ACTION = 9, + DESCRIBE_CONFIGS = 10, + ALTER_CONFIGS = 11, + IDEMPOTENT_WRITE = 12 + + +class ACLPermissionType(IntEnum): + """An enumerated type of permissions + + The ANY value is only valid in a filter context + """ + + ANY = 1, + DENY = 2, + ALLOW = 3 + + +class ACLResourcePatternType(IntEnum): + """An enumerated type of resource patterns + + More details on the pattern types and how they work + can be found in KIP-290 (Support for prefixed ACLs) + https://cwiki.apache.org/confluence/display/KAFKA/KIP-290%3A+Support+for+Prefixed+ACLs + """ + + ANY = 1, + MATCH = 2, + LITERAL = 3, + PREFIXED = 4 + + +class ACLFilter(object): + """Represents a filter to use with describing and deleting ACLs + + The difference between this class and the ACL class is mainly that + we allow using ANY with the operation, permission, and resource type objects + to fetch ALCs matching any of the properties. + + To make a filter matching any principal, set principal to None + """ + + def __init__( + self, + principal, + host, + operation, + permission_type, + resource_pattern + ): + self.principal = principal + self.host = host + self.operation = operation + self.permission_type = permission_type + self.resource_pattern = resource_pattern + + self.validate() + + def validate(self): + if not isinstance(self.operation, ACLOperation): + raise IllegalArgumentError("operation must be an ACLOperation object, and cannot be ANY") + if not isinstance(self.permission_type, ACLPermissionType): + raise IllegalArgumentError("permission_type must be an ACLPermissionType object, and cannot be ANY") + if not isinstance(self.resource_pattern, ResourcePatternFilter): + raise IllegalArgumentError("resource_pattern must be a ResourcePatternFilter object") + + def __repr__(self): + return "<ACL principal={principal}, resource={resource}, operation={operation}, type={type}, host={host}>".format( + principal=self.principal, + host=self.host, + operation=self.operation.name, + type=self.permission_type.name, + resource=self.resource_pattern + ) + + +class ACL(ACLFilter): + """Represents a concrete ACL for a specific ResourcePattern + + In kafka an ACL is a 4-tuple of (principal, host, operation, permission_type) + that limits who can do what on a specific resource (or since KIP-290 a resource pattern) + + Terminology: + Principal -> This is the identifier for the user. Depending on the authorization method used (SSL, SASL etc) + the principal will look different. See http://kafka.apache.org/documentation/#security_authz for details. + The principal must be on the format "User:<name>" or kafka will treat it as invalid. It's possible to use + other principal types than "User" if using a custom authorizer for the cluster. + Host -> This must currently be an IP address. It cannot be a range, and it cannot be a domain name. + It can be set to "*", which is special cased in kafka to mean "any host" + Operation -> Which client operation this ACL refers to. Has different meaning depending + on the resource type the ACL refers to. See https://docs.confluent.io/current/kafka/authorization.html#acl-format + for a list of which combinations of resource/operation that unlocks which kafka APIs + Permission Type: Whether this ACL is allowing or denying access + Resource Pattern -> This is a representation of the resource or resource pattern that the ACL + refers to. See the ResourcePattern class for details. + + """ + + def __init__( + self, + principal, + host, + operation, + permission_type, + resource_pattern + ): + super(ACL, self).__init__(principal, host, operation, permission_type, resource_pattern) + self.validate() + + def validate(self): + if self.operation == ACLOperation.ANY: + raise IllegalArgumentError("operation cannot be ANY") + if self.permission_type == ACLPermissionType.ANY: + raise IllegalArgumentError("permission_type cannot be ANY") + if not isinstance(self.resource_pattern, ResourcePattern): + raise IllegalArgumentError("resource_pattern must be a ResourcePattern object") + + +class ResourcePatternFilter(object): + def __init__( + self, + resource_type, + resource_name, + pattern_type + ): + self.resource_type = resource_type + self.resource_name = resource_name + self.pattern_type = pattern_type + + self.validate() + + def validate(self): + if not isinstance(self.resource_type, ResourceType): + raise IllegalArgumentError("resource_type must be a ResourceType object") + if not isinstance(self.pattern_type, ACLResourcePatternType): + raise IllegalArgumentError("pattern_type must be an ACLResourcePatternType object") + + def __repr__(self): + return "<ResourcePattern type={}, name={}, pattern={}>".format( + self.resource_type.name, + self.resource_name, + self.pattern_type.name + ) + + +class ResourcePattern(ResourcePatternFilter): + """A resource pattern to apply the ACL to + + Resource patterns are used to be able to specify which resources an ACL + describes in a more flexible way than just pointing to a literal topic name for example. + Since KIP-290 (kafka 2.0) it's possible to set an ACL for a prefixed resource name, which + can cut down considerably on the number of ACLs needed when the number of topics and + consumer groups start to grow. + The default pattern_type is LITERAL, and it describes a specific resource. This is also how + ACLs worked before the introduction of prefixed ACLs + """ + + def __init__( + self, + resource_type, + resource_name, + pattern_type=ACLResourcePatternType.LITERAL + ): + super(ResourcePattern, self).__init__(resource_type, resource_name, pattern_type) + self.validate() + + def validate(self): + if self.resource_type == ResourceType.ANY: + raise IllegalArgumentError("resource_type cannot be ANY") + if self.pattern_type in [ACLResourcePatternType.ANY, ACLResourcePatternType.MATCH]: + raise IllegalArgumentError( + "pattern_type cannot be {} on a concrete ResourcePattern".format(self.pattern_type.name) + ) \ No newline at end of file diff --git a/kafka/admin/client.py b/kafka/admin/client.py index 155ad21d6..0e3e8a184 100644 --- a/kafka/admin/client.py +++ b/kafka/admin/client.py @@ -11,14 +11,16 @@ import kafka.errors as Errors from kafka.errors import ( IncompatibleBrokerVersion, KafkaConfigurationError, NotControllerError, - UnrecognizedBrokerVersion) + UnrecognizedBrokerVersion, IllegalArgumentError) from kafka.metrics import MetricConfig, Metrics from kafka.protocol.admin import ( CreateTopicsRequest, DeleteTopicsRequest, DescribeConfigsRequest, AlterConfigsRequest, CreatePartitionsRequest, - ListGroupsRequest, DescribeGroupsRequest) + ListGroupsRequest, DescribeGroupsRequest, DescribeAclsRequest, CreateAclsRequest, DeleteAclsRequest) from kafka.protocol.commit import GroupCoordinatorRequest, OffsetFetchRequest from kafka.protocol.metadata import MetadataRequest from kafka.structs import TopicPartition, OffsetAndMetadata +from kafka.admin.acl_resource import ACLOperation, ACLPermissionType, ACLFilter, ACL, ResourcePattern, ResourceType, \ + ACLResourcePatternType from kafka.version import __version__ @@ -450,14 +452,269 @@ def delete_topics(self, topics, timeout_ms=None): # describe cluster functionality is in ClusterMetadata # Note: if implemented here, send the request to the least_loaded_node() - # describe_acls protocol not yet implemented - # Note: send the request to the least_loaded_node() + @staticmethod + def _convert_describe_acls_response_to_acls(describe_response): + version = describe_response.API_VERSION + + error = Errors.for_code(describe_response.error_code) + acl_list = [] + for resources in describe_response.resources: + if version == 0: + resource_type, resource_name, acls = resources + resource_pattern_type = ACLResourcePatternType.LITERAL.value + elif version <= 1: + resource_type, resource_name, resource_pattern_type, acls = resources + else: + raise NotImplementedError( + "Support for DescribeAcls Response v{} has not yet been added to KafkaAdmin." + .format(version) + ) + for acl in acls: + principal, host, operation, permission_type = acl + conv_acl = ACL( + principal=principal, + host=host, + operation=ACLOperation(operation), + permission_type=ACLPermissionType(permission_type), + resource_pattern=ResourcePattern( + ResourceType(resource_type), + resource_name, + ACLResourcePatternType(resource_pattern_type) + ) + ) + acl_list.append(conv_acl) + + return (acl_list, error,) + + def describe_acls(self, acl_filter): + """Describe a set of ACLs + + Used to return a set of ACLs matching the supplied ACLFilter. + The cluster must be configured with an authorizer for this to work, or + you will get a SecurityDisabledError + + :param acl_filter: an ACLFilter object + :return: tuple of a list of matching ACL objects and a KafkaError (NoError if successful) + """ - # create_acls protocol not yet implemented - # Note: send the request to the least_loaded_node() + version = self._matching_api_version(DescribeAclsRequest) + if version == 0: + request = DescribeAclsRequest[version]( + resource_type=acl_filter.resource_pattern.resource_type, + resource_name=acl_filter.resource_pattern.resource_name, + principal=acl_filter.principal, + host=acl_filter.host, + operation=acl_filter.operation, + permission_type=acl_filter.permission_type + ) + elif version <= 1: + request = DescribeAclsRequest[version]( + resource_type=acl_filter.resource_pattern.resource_type, + resource_name=acl_filter.resource_pattern.resource_name, + resource_pattern_type_filter=acl_filter.resource_pattern.pattern_type, + principal=acl_filter.principal, + host=acl_filter.host, + operation=acl_filter.operation, + permission_type=acl_filter.permission_type - # delete_acls protocol not yet implemented - # Note: send the request to the least_loaded_node() + ) + else: + raise NotImplementedError( + "Support for DescribeAcls v{} has not yet been added to KafkaAdmin." + .format(version) + ) + + future = self._send_request_to_node(self._client.least_loaded_node(), request) + self._wait_for_futures([future]) + response = future.value + + error_type = Errors.for_code(response.error_code) + if error_type is not Errors.NoError: + # optionally we could retry if error_type.retriable + raise error_type( + "Request '{}' failed with response '{}'." + .format(request, response)) + + return self._convert_describe_acls_response_to_acls(response) + + @staticmethod + def _convert_create_acls_resource_request_v0(acl): + + return ( + acl.resource_pattern.resource_type, + acl.resource_pattern.resource_name, + acl.principal, + acl.host, + acl.operation, + acl.permission_type + ) + + @staticmethod + def _convert_create_acls_resource_request_v1(acl): + + return ( + acl.resource_pattern.resource_type, + acl.resource_pattern.resource_name, + acl.resource_pattern.pattern_type, + acl.principal, + acl.host, + acl.operation, + acl.permission_type + ) + + @staticmethod + def _convert_create_acls_response_to_acls(acls, create_response): + version = create_response.API_VERSION + + creations_error = [] + creations_success = [] + for i, creations in enumerate(create_response.creation_responses): + if version <= 1: + error_code, error_message = creations + acl = acls[i] + error = Errors.for_code(error_code) + else: + raise NotImplementedError( + "Support for DescribeAcls Response v{} has not yet been added to KafkaAdmin." + .format(version) + ) + + if error is Errors.NoError: + creations_success.append(acl) + else: + creations_error.append((acl, error,)) + + return {"succeeded": creations_success, "failed": creations_error} + + def create_acls(self, acls): + """Create a list of ACLs + + This endpoint only accepts a list of concrete ACL objects, no ACLFilters. + Throws TopicAlreadyExistsError if topic is already present. + + :param acls: a list of ACL objects + :return: dict of successes and failures + """ + + for acl in acls: + if not isinstance(acl, ACL): + raise IllegalArgumentError("acls must contain ACL objects") + + version = self._matching_api_version(CreateAclsRequest) + if version == 0: + request = CreateAclsRequest[version]( + creations=[self._convert_create_acls_resource_request_v0(acl) for acl in acls] + ) + elif version <= 1: + request = CreateAclsRequest[version]( + creations=[self._convert_create_acls_resource_request_v1(acl) for acl in acls] + ) + else: + raise NotImplementedError( + "Support for CreateAcls v{} has not yet been added to KafkaAdmin." + .format(version) + ) + + future = self._send_request_to_node(self._client.least_loaded_node(), request) + self._wait_for_futures([future]) + response = future.value + + + return self._convert_create_acls_response_to_acls(acls, response) + + @staticmethod + def _convert_delete_acls_resource_request_v0(acl): + return ( + acl.resource_pattern.resource_type, + acl.resource_pattern.resource_name, + acl.principal, + acl.host, + acl.operation, + acl.permission_type + ) + + @staticmethod + def _convert_delete_acls_resource_request_v1(acl): + return ( + acl.resource_pattern.resource_type, + acl.resource_pattern.resource_name, + acl.resource_pattern.pattern_type, + acl.principal, + acl.host, + acl.operation, + acl.permission_type + ) + + @staticmethod + def _convert_delete_acls_response_to_matching_acls(acl_filters, delete_response): + version = delete_response.API_VERSION + filter_result_list = [] + for i, filter_responses in enumerate(delete_response.filter_responses): + filter_error_code, filter_error_message, matching_acls = filter_responses + filter_error = Errors.for_code(filter_error_code) + acl_result_list = [] + for acl in matching_acls: + if version == 0: + error_code, error_message, resource_type, resource_name, principal, host, operation, permission_type = acl + resource_pattern_type = ACLResourcePatternType.LITERAL.value + elif version == 1: + error_code, error_message, resource_type, resource_name, resource_pattern_type, principal, host, operation, permission_type = acl + else: + raise NotImplementedError( + "Support for DescribeAcls Response v{} has not yet been added to KafkaAdmin." + .format(version) + ) + acl_error = Errors.for_code(error_code) + conv_acl = ACL( + principal=principal, + host=host, + operation=ACLOperation(operation), + permission_type=ACLPermissionType(permission_type), + resource_pattern=ResourcePattern( + ResourceType(resource_type), + resource_name, + ACLResourcePatternType(resource_pattern_type) + ) + ) + acl_result_list.append((conv_acl, acl_error,)) + filter_result_list.append((acl_filters[i], acl_result_list, filter_error,)) + return filter_result_list + + def delete_acls(self, acl_filters): + """Delete a set of ACLs + + Deletes all ACLs matching the list of input ACLFilter + + :param acl_filters: a list of ACLFilter + :return: a list of 3-tuples corresponding to the list of input filters. + The tuples hold (the input ACLFilter, list of affected ACLs, KafkaError instance) + """ + + for acl in acl_filters: + if not isinstance(acl, ACLFilter): + raise IllegalArgumentError("acl_filters must contain ACLFilter type objects") + + version = self._matching_api_version(DeleteAclsRequest) + + if version == 0: + request = DeleteAclsRequest[version]( + filters=[self._convert_delete_acls_resource_request_v0(acl) for acl in acl_filters] + ) + elif version <= 1: + request = DeleteAclsRequest[version]( + filters=[self._convert_delete_acls_resource_request_v1(acl) for acl in acl_filters] + ) + else: + raise NotImplementedError( + "Support for DeleteAcls v{} has not yet been added to KafkaAdmin." + .format(version) + ) + + future = self._send_request_to_node(self._client.least_loaded_node(), request) + self._wait_for_futures([future]) + response = future.value + + return self._convert_delete_acls_response_to_matching_acls(acl_filters, response) @staticmethod def _convert_describe_config_resource_request(config_resource): diff --git a/kafka/errors.py b/kafka/errors.py index f13f97853..abef2c5bf 100644 --- a/kafka/errors.py +++ b/kafka/errors.py @@ -443,6 +443,12 @@ class PolicyViolationError(BrokerResponseError): description = 'Request parameters do not satisfy the configured policy.' +class SecurityDisabledError(BrokerResponseError): + errno = 54 + message = 'SECURITY_DISABLED' + description = 'Security features are disabled.' + + class KafkaUnavailableError(KafkaError): pass diff --git a/servers/0.10.0.0/resources/kafka.properties b/servers/0.10.0.0/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.10.0.0/resources/kafka.properties +++ b/servers/0.10.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.10.0.1/resources/kafka.properties b/servers/0.10.0.1/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.10.0.1/resources/kafka.properties +++ b/servers/0.10.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.10.1.1/resources/kafka.properties b/servers/0.10.1.1/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.10.1.1/resources/kafka.properties +++ b/servers/0.10.1.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.10.2.1/resources/kafka.properties b/servers/0.10.2.1/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.10.2.1/resources/kafka.properties +++ b/servers/0.10.2.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.11.0.0/resources/kafka.properties b/servers/0.11.0.0/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/0.11.0.0/resources/kafka.properties +++ b/servers/0.11.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.11.0.1/resources/kafka.properties b/servers/0.11.0.1/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/0.11.0.1/resources/kafka.properties +++ b/servers/0.11.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.11.0.2/resources/kafka.properties b/servers/0.11.0.2/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/0.11.0.2/resources/kafka.properties +++ b/servers/0.11.0.2/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.9.0.0/resources/kafka.properties b/servers/0.9.0.0/resources/kafka.properties index b4c4088db..a8aaa284a 100644 --- a/servers/0.9.0.0/resources/kafka.properties +++ b/servers/0.9.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.9.0.1/resources/kafka.properties b/servers/0.9.0.1/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.9.0.1/resources/kafka.properties +++ b/servers/0.9.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.0.0/resources/kafka.properties b/servers/1.0.0/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/1.0.0/resources/kafka.properties +++ b/servers/1.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.0.1/resources/kafka.properties b/servers/1.0.1/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/1.0.1/resources/kafka.properties +++ b/servers/1.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.0.2/resources/kafka.properties b/servers/1.0.2/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/1.0.2/resources/kafka.properties +++ b/servers/1.0.2/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.1.0/resources/kafka.properties b/servers/1.1.0/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/1.1.0/resources/kafka.properties +++ b/servers/1.1.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.1.1/resources/kafka.properties b/servers/1.1.1/resources/kafka.properties index 64f94d528..fe6a89f4a 100644 --- a/servers/1.1.1/resources/kafka.properties +++ b/servers/1.1.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # List of enabled mechanisms, can be more than one sasl.enabled.mechanisms=PLAIN sasl.mechanism.inter.broker.protocol=PLAIN diff --git a/servers/2.0.0/resources/kafka.properties b/servers/2.0.0/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/2.0.0/resources/kafka.properties +++ b/servers/2.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/2.0.1/resources/kafka.properties b/servers/2.0.1/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/2.0.1/resources/kafka.properties +++ b/servers/2.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092

diff --git a/test/test_admin.py b/test/test_admin.py index 300d5bced..279f85abf 100644 --- a/test/test_admin.py +++ b/test/test_admin.py @@ -26,6 +26,37 @@ def test_new_partitions(): assert good_partitions.new_assignments == [[1, 2, 3]] +def test_acl_resource(): + good_acl = kafka.admin.ACL( + "User:bar", + "*", + kafka.admin.ACLOperation.ALL, + kafka.admin.ACLPermissionType.ALLOW, + kafka.admin.ResourcePattern( + kafka.admin.ResourceType.TOPIC, + "foo", + kafka.admin.ACLResourcePatternType.LITERAL + ) + ) + + assert(good_acl.resource_pattern.resource_type == kafka.admin.ResourceType.TOPIC) + assert(good_acl.operation == kafka.admin.ACLOperation.ALL) + assert(good_acl.permission_type == kafka.admin.ACLPermissionType.ALLOW) + assert(good_acl.resource_pattern.pattern_type == kafka.admin.ACLResourcePatternType.LITERAL) + + with pytest.raises(IllegalArgumentError): + kafka.admin.ACL( + "User:bar", + "*", + kafka.admin.ACLOperation.ANY, + kafka.admin.ACLPermissionType.ANY, + kafka.admin.ResourcePattern( + kafka.admin.ResourceType.TOPIC, + "foo", + kafka.admin.ACLResourcePatternType.LITERAL + ) + ) + def test_new_topic(): with pytest.raises(IllegalArgumentError): bad_topic = kafka.admin.NewTopic('foo', -1, -1) diff --git a/test/test_admin_integration.py b/test/test_admin_integration.py new file mode 100644 index 000000000..0be192001 --- /dev/null +++ b/test/test_admin_integration.py @@ -0,0 +1,107 @@ +import pytest +import os + +from test.fixtures import ZookeeperFixture, KafkaFixture, version +from test.testutil import KafkaIntegrationTestCase, kafka_versions, current_offset + +from kafka.errors import NoError +from kafka.admin import KafkaAdminClient, ACLFilter, ACLOperation, ACLPermissionType, ResourcePattern, ResourceType, ACL + + +class TestAdminClientIntegration(KafkaIntegrationTestCase): + @classmethod + def setUpClass(cls): # noqa + if not os.environ.get('KAFKA_VERSION'): + return + + cls.zk = ZookeeperFixture.instance() + cls.server = KafkaFixture.instance(0, cls.zk) + + @classmethod + def tearDownClass(cls): # noqa + if not os.environ.get('KAFKA_VERSION'): + return + + cls.server.close() + cls.zk.close() + + @kafka_versions('>=0.9.0') + def test_create_describe_delete_acls(self): + """Tests that we can add, list and remove ACLs + """ + + # Setup + brokers = '%s:%d' % (self.server.host, self.server.port) + admin_client = KafkaAdminClient( + bootstrap_servers=brokers + ) + + # Check that we don't have any ACLs in the cluster + acls, error = admin_client.describe_acls( + ACLFilter( + principal=None, + host="*", + operation=ACLOperation.ANY, + permission_type=ACLPermissionType.ANY, + resource_pattern=ResourcePattern(ResourceType.TOPIC, "topic") + ) + ) + + self.assertIs(error, NoError) + self.assertEqual(0, len(acls)) + + # Try to add an ACL + acl = ACL( + principal="User:test", + host="*", + operation=ACLOperation.READ, + permission_type=ACLPermissionType.ALLOW, + resource_pattern=ResourcePattern(ResourceType.TOPIC, "topic") + ) + result = admin_client.create_acls([acl]) + + self.assertFalse(len(result["failed"])) + self.assertEqual(len(result["succeeded"]), 1) + + # Check that we can list the ACL we created + acl_filter = ACLFilter( + principal=None, + host="*", + operation=ACLOperation.ANY, + permission_type=ACLPermissionType.ANY, + resource_pattern=ResourcePattern(ResourceType.TOPIC, "topic") + ) + acls, error = admin_client.describe_acls(acl_filter) + + self.assertIs(error, NoError) + self.assertEqual(1, len(acls)) + + # Remove the ACL + delete_results = admin_client.delete_acls( + [ + ACLFilter( + principal="User:test", + host="*", + operation=ACLOperation.READ, + permission_type=ACLPermissionType.ALLOW, + resource_pattern=ResourcePattern(ResourceType.TOPIC, "topic") + ) + ] + ) + + self.assertEqual(1, len(delete_results)) + self.assertEqual(1, len(delete_results[0][1])) # Check number of affected ACLs + + + # Make sure the ACL does not exist in the cluster anymore + acls, error = admin_client.describe_acls( + ACLFilter( + principal="*", + host="*", + operation=ACLOperation.ANY, + permission_type=ACLPermissionType.ANY, + resource_pattern=ResourcePattern(ResourceType.TOPIC, "topic") + ) + ) + self.assertIs(error, NoError) + self.assertEqual(0, len(acls))

diff --git a/servers/0.10.0.0/resources/kafka.properties b/servers/0.10.0.0/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.10.0.0/resources/kafka.properties +++ b/servers/0.10.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.10.0.1/resources/kafka.properties b/servers/0.10.0.1/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.10.0.1/resources/kafka.properties +++ b/servers/0.10.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.10.1.1/resources/kafka.properties b/servers/0.10.1.1/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.10.1.1/resources/kafka.properties +++ b/servers/0.10.1.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.10.2.1/resources/kafka.properties b/servers/0.10.2.1/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.10.2.1/resources/kafka.properties +++ b/servers/0.10.2.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.11.0.0/resources/kafka.properties b/servers/0.11.0.0/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/0.11.0.0/resources/kafka.properties +++ b/servers/0.11.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.11.0.1/resources/kafka.properties b/servers/0.11.0.1/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/0.11.0.1/resources/kafka.properties +++ b/servers/0.11.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.11.0.2/resources/kafka.properties b/servers/0.11.0.2/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/0.11.0.2/resources/kafka.properties +++ b/servers/0.11.0.2/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.9.0.0/resources/kafka.properties b/servers/0.9.0.0/resources/kafka.properties index b4c4088db..a8aaa284a 100644 --- a/servers/0.9.0.0/resources/kafka.properties +++ b/servers/0.9.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/0.9.0.1/resources/kafka.properties b/servers/0.9.0.1/resources/kafka.properties index 7d8e2b1f0..534b7ba36 100644 --- a/servers/0.9.0.1/resources/kafka.properties +++ b/servers/0.9.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.0.0/resources/kafka.properties b/servers/1.0.0/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/1.0.0/resources/kafka.properties +++ b/servers/1.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.0.1/resources/kafka.properties b/servers/1.0.1/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/1.0.1/resources/kafka.properties +++ b/servers/1.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.0.2/resources/kafka.properties b/servers/1.0.2/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/1.0.2/resources/kafka.properties +++ b/servers/1.0.2/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.1.0/resources/kafka.properties b/servers/1.1.0/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/1.1.0/resources/kafka.properties +++ b/servers/1.1.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/1.1.1/resources/kafka.properties b/servers/1.1.1/resources/kafka.properties index 64f94d528..fe6a89f4a 100644 --- a/servers/1.1.1/resources/kafka.properties +++ b/servers/1.1.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # List of enabled mechanisms, can be more than one sasl.enabled.mechanisms=PLAIN sasl.mechanism.inter.broker.protocol=PLAIN diff --git a/servers/2.0.0/resources/kafka.properties b/servers/2.0.0/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/2.0.0/resources/kafka.properties +++ b/servers/2.0.0/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092 diff --git a/servers/2.0.1/resources/kafka.properties b/servers/2.0.1/resources/kafka.properties index 28668db95..630dbc5fa 100644 --- a/servers/2.0.1/resources/kafka.properties +++ b/servers/2.0.1/resources/kafka.properties @@ -30,6 +30,9 @@ ssl.key.password=foobar ssl.truststore.location={ssl_dir}/kafka.server.truststore.jks ssl.truststore.password=foobar +authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer +allow.everyone.if.no.acl.found=true + # The port the socket server listens on #port=9092

[ { "components": [ { "doc": "Type of kafka resource to set ACL for\n\nThe ANY value is only valid in a filter context", "lines": [ 12, 24 ], "name": "ResourceType", "signature": "class ResourceType(IntEnum):", "type": "class" }, ...

[ "test/test_admin.py::test_config_resource", "test/test_admin.py::test_new_partitions", "test/test_admin.py::test_acl_resource", "test/test_admin.py::test_new_topic" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add ACL api to KafkaAdminClient This is a new attempt at creating user friendly ACL management methods to KafkaAdminClient. It's building on top of the previous PR (#1646) that only got the protocol stuff merged b.c there were remaining issues to deal with in the api part, and not much time. I think I've covered all the feedback from that PR in this one. I'm ready for a new round of review, hopefully I can find enough time for fixes and tweaks to land the whole thing this time =) Fixes #1638  --- This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/dpkp/kafka-python/1833)  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in kafka/admin/acl_resource.py] (definition of ResourceType:) class ResourceType(IntEnum): """Type of kafka resource to set ACL for The ANY value is only valid in a filter context""" (definition of ACLOperation:) class ACLOperation(IntEnum): """Type of operation The ANY value is only valid in a filter context""" (definition of ACLPermissionType:) class ACLPermissionType(IntEnum): """An enumerated type of permissions The ANY value is only valid in a filter context""" (definition of ACLResourcePatternType:) class ACLResourcePatternType(IntEnum): """An enumerated type of resource patterns More details on the pattern types and how they work can be found in KIP-290 (Support for prefixed ACLs) https://cwiki.apache.org/confluence/display/KAFKA/KIP-290%3A+Support+for+Prefixed+ACLs""" (definition of ACLFilter:) class ACLFilter(object): """Represents a filter to use with describing and deleting ACLs The difference between this class and the ACL class is mainly that we allow using ANY with the operation, permission, and resource type objects to fetch ALCs matching any of the properties. To make a filter matching any principal, set principal to None""" (definition of ACLFilter.__init__:) def __init__( self, principal, host, operation, permission_type, resource_pattern ): (definition of ACLFilter.validate:) def validate(self): (definition of ACLFilter.__repr__:) def __repr__(self): (definition of ACL:) class ACL(ACLFilter): """Represents a concrete ACL for a specific ResourcePattern In kafka an ACL is a 4-tuple of (principal, host, operation, permission_type) that limits who can do what on a specific resource (or since KIP-290 a resource pattern) Terminology: Principal -> This is the identifier for the user. Depending on the authorization method used (SSL, SASL etc) the principal will look different. See http://kafka.apache.org/documentation/#security_authz for details. The principal must be on the format "User:<name>" or kafka will treat it as invalid. It's possible to use other principal types than "User" if using a custom authorizer for the cluster. Host -> This must currently be an IP address. It cannot be a range, and it cannot be a domain name. It can be set to "*", which is special cased in kafka to mean "any host" Operation -> Which client operation this ACL refers to. Has different meaning depending on the resource type the ACL refers to. See https://docs.confluent.io/current/kafka/authorization.html#acl-format for a list of which combinations of resource/operation that unlocks which kafka APIs Permission Type: Whether this ACL is allowing or denying access Resource Pattern -> This is a representation of the resource or resource pattern that the ACL refers to. See the ResourcePattern class for details.""" (definition of ACL.__init__:) def __init__( self, principal, host, operation, permission_type, resource_pattern ): (definition of ACL.validate:) def validate(self): (definition of ResourcePatternFilter:) class ResourcePatternFilter(object): (definition of ResourcePatternFilter.__init__:) def __init__( self, resource_type, resource_name, pattern_type ): (definition of ResourcePatternFilter.validate:) def validate(self): (definition of ResourcePatternFilter.__repr__:) def __repr__(self): (definition of ResourcePattern:) class ResourcePattern(ResourcePatternFilter): """A resource pattern to apply the ACL to Resource patterns are used to be able to specify which resources an ACL describes in a more flexible way than just pointing to a literal topic name for example. Since KIP-290 (kafka 2.0) it's possible to set an ACL for a prefixed resource name, which can cut down considerably on the number of ACLs needed when the number of topics and consumer groups start to grow. The default pattern_type is LITERAL, and it describes a specific resource. This is also how ACLs worked before the introduction of prefixed ACLs""" (definition of ResourcePattern.__init__:) def __init__( self, resource_type, resource_name, pattern_type=ACLResourcePatternType.LITERAL ): (definition of ResourcePattern.validate:) def validate(self): [end of new definitions in kafka/admin/acl_resource.py] [start of new definitions in kafka/admin/client.py] (definition of KafkaAdminClient._convert_describe_acls_response_to_acls:) def _convert_describe_acls_response_to_acls(describe_response): (definition of KafkaAdminClient.describe_acls:) def describe_acls(self, acl_filter): """Describe a set of ACLs Used to return a set of ACLs matching the supplied ACLFilter. The cluster must be configured with an authorizer for this to work, or you will get a SecurityDisabledError :param acl_filter: an ACLFilter object :return: tuple of a list of matching ACL objects and a KafkaError (NoError if successful)""" (definition of KafkaAdminClient._convert_create_acls_resource_request_v0:) def _convert_create_acls_resource_request_v0(acl): (definition of KafkaAdminClient._convert_create_acls_resource_request_v1:) def _convert_create_acls_resource_request_v1(acl): (definition of KafkaAdminClient._convert_create_acls_response_to_acls:) def _convert_create_acls_response_to_acls(acls, create_response): (definition of KafkaAdminClient.create_acls:) def create_acls(self, acls): """Create a list of ACLs This endpoint only accepts a list of concrete ACL objects, no ACLFilters. Throws TopicAlreadyExistsError if topic is already present. :param acls: a list of ACL objects :return: dict of successes and failures""" (definition of KafkaAdminClient._convert_delete_acls_resource_request_v0:) def _convert_delete_acls_resource_request_v0(acl): (definition of KafkaAdminClient._convert_delete_acls_resource_request_v1:) def _convert_delete_acls_resource_request_v1(acl): (definition of KafkaAdminClient._convert_delete_acls_response_to_matching_acls:) def _convert_delete_acls_response_to_matching_acls(acl_filters, delete_response): (definition of KafkaAdminClient.delete_acls:) def delete_acls(self, acl_filters): """Delete a set of ACLs Deletes all ACLs matching the list of input ACLFilter :param acl_filters: a list of ACLFilter :return: a list of 3-tuples corresponding to the list of input filters. The tuples hold (the input ACLFilter, list of affected ACLs, KafkaError instance)""" [end of new definitions in kafka/admin/client.py] [start of new definitions in kafka/errors.py] (definition of SecurityDisabledError:) class SecurityDisabledError(BrokerResponseError): [end of new definitions in kafka/errors.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Add ACL kafka protocols to AdminClient I could not find any mention in these issues of adding ACL protocols to this project. Is that something that would be attractive to add? I could try and add the Create/Delete/Describe protocols and implement methods for them in the AdminClient in that case. I'm currently using the kafka supplied shellscripts for managing Acls, but I find them very clunky and resource heavy, so being able to use kafka-python for that would be great =) ---------- Great idea! I havent looked at ACL admin protocols. On Thu, Nov 15, 2018, 3:07 PM Ulrik Johansson <notifications@github.com wrote: > I could not find any mention in these issues of adding ACL protocols to > this project. Is that something that would be attractive to add? > I could try and add the Create/Delete/Describe protocols and implement > methods for them in the AdminClient in that case. > > I'm currently using the kafka supplied shellscripts for managing Acls, but > I find them very clunky and resource heavy, so being able to use > kafka-python for that would be great =) > > — > You are receiving this because you are subscribed to this thread. > Reply to this email directly, view it on GitHub > <https://github.com/dpkp/kafka-python/issues/1638>, or mute the thread > <https://github.com/notifications/unsubscribe-auth/AAzetA2glKIx-j3uihRHC50_FijEGZ1nks5uvfOxgaJpZM4Yjl5m> > . > -------------------- </issues>

53dc740bce8ef19c32fad2881021d1f6bb055f7a

joke2k__faker-964

964

joke2k/faker

null

89eefd7962928b3150e72707fc8718613ab63e63

2019-05-27T10:39:41Z

diff --git a/faker/providers/person/pl_PL/__init__.py b/faker/providers/person/pl_PL/__init__.py index 49c622df8a..025b50f135 100644 --- a/faker/providers/person/pl_PL/__init__.py +++ b/faker/providers/person/pl_PL/__init__.py @@ -21,28 +21,6 @@ def checksum_identity_card_number(characters): return check_digit -def generate_pesel_checksum_value(pesel_digits): - """ - Calculates and returns a control digit for given PESEL. - """ - checksum_values = [9, 7, 3, 1, 9, 7, 3, 1, 9, 7] - - checksum = sum((int(a) * b for a, b in zip(list(pesel_digits), checksum_values))) - - return checksum % 10 - - -def checksum_pesel_number(pesel_digits): - """ - Calculates and returns True if PESEL is valid. - """ - checksum_values = [1, 3, 7, 9, 1, 3, 7, 9, 1, 3, 1] - - checksum = sum((int(a) * b for a, b in zip(list(pesel_digits), checksum_values))) - - return checksum % 10 == 0 - - class Provider(PersonProvider): formats = ( '{{first_name}} {{last_name}}', @@ -725,30 +703,74 @@ def identity_card_number(self): return ''.join(str(character) for character in identity) - def pesel(self): + @staticmethod + def pesel_compute_check_digit(pesel): + checksum_values = [9, 7, 3, 1, 9, 7, 3, 1, 9, 7] + return sum(int(a) * b for a, b in zip(pesel, checksum_values)) % 10 + + def pesel(self, date_of_birth=None, sex=None): """ Returns 11 characters of Universal Electronic System for Registration of the Population. Polish: Powszechny Elektroniczny System Ewidencji Ludności. PESEL has 11 digits which identifies just one person. - Month: if person was born in 1900-2000, december is 12. If person was born > 2000, we have to add 20 to month, - so december is 32. - Person id: last digit identifies person's sex. Even for females, odd for males. + pesel_date: if person was born in 1900-2000, december is 12. If person was born > 2000, we have to add 20 to + month, so december is 32. + pesel_sex: last digit identifies person's sex. Even for females, odd for males. https://en.wikipedia.org/wiki/PESEL """ + if date_of_birth is None: + date_of_birth = self.generator.date_of_birth() - birth = self.generator.date_of_birth() + pesel_date = '{year}{month:02d}{day:02d}'.format( + year=date_of_birth.year, day=date_of_birth.day, + month=date_of_birth.month if date_of_birth.year < 2000 else date_of_birth.month + 20) + pesel_date = pesel_date[2:] - year_pesel = str(birth.year)[-2:] - month_pesel = birth.month if birth.year < 2000 else birth.month + 20 - day_pesel = birth.day - person_id = self.random_int(1000, 9999) + pesel_core = ''.join(map(str, (self.random_digit() for _ in range(3)))) + pesel_sex = self.random_digit() - current_pesel = '{year}{month:02d}{day:02d}{person_id:04d}'.format(year=year_pesel, month=month_pesel, - day=day_pesel, - person_id=person_id) + if (sex == 'M' and pesel_sex % 2 == 0) or (sex == 'F' and pesel_sex % 2 == 1): + pesel_sex = (pesel_sex + 1) % 10 + + pesel = '{date}{core}{sex}'.format(date=pesel_date, core=pesel_core, sex=pesel_sex) + pesel += str(self.pesel_compute_check_digit(pesel)) + + return pesel + + @staticmethod + def pwz_doctor_compute_check_digit(x): + return sum((i+1)*d for i, d in enumerate(x)) % 11 + + def pwz_doctor(self): + """ + Function generates an identification number for medical doctors + Polish: Prawo Wykonywania Zawodu (PWZ) + + https://www.nil.org.pl/rejestry/centralny-rejestr-lekarzy/zasady-weryfikowania-nr-prawa-wykonywania-zawodu + """ + core = [self.random_digit() for _ in range(6)] + check_digit = self.pwz_doctor_compute_check_digit(core) + + if check_digit == 0: + core[-1] = (core[-1] + 1) % 10 + check_digit = self.pwz_doctor_compute_check_digit(core) + + return '{}{}'.format(check_digit, ''.join(map(str, core))) + + def pwz_nurse(self, kind='nurse'): + """ + Function generates an identification number for nurses and midwives + Polish: Prawo Wykonywania Zawodu (PWZ) + + http://arch.nipip.pl/index.php/prawo/uchwaly/naczelnych-rad/w-roku-2015/posiedzenie-15-17-grudnia/3664-uchwala- + nr-381-vi-2015-w-sprawie-trybu-postepowania-dotyczacego-stwierdzania-i-przyznawania-prawa-wykonywania-zawodu-pi + elegniarki-i-zawodu-poloznej-oraz-sposobu-prowadzenia-rejestru-pielegniarek-i-rejestru-poloznych-przez-okregowe + -rady-pielegniarek-i-polo + """ + region = self.random_int(1, 45) + core = [self.random_digit() for _ in range(5)] + kind_char = 'A' if kind == 'midwife' else 'P' - checksum_value = generate_pesel_checksum_value(current_pesel) - return '{pesel_without_checksum}{checksum_value}'.format(pesel_without_checksum=current_pesel, - checksum_value=checksum_value) + return '{:02d}{}{}'.format(region, ''.join(map(str, core)), kind_char)

diff --git a/tests/providers/test_person.py b/tests/providers/test_person.py index 3767ef4d89..90b8d4c2ca 100644 --- a/tests/providers/test_person.py +++ b/tests/providers/test_person.py @@ -4,9 +4,14 @@ import re import unittest - +import datetime import six +try: + from unittest import mock +except ImportError: + import mock + from faker import Faker from faker.providers.person.ar_AA import Provider as ArProvider from faker.providers.person.fi_FI import Provider as FiProvider @@ -14,9 +19,9 @@ from faker.providers.person.ne_NP import Provider as NeProvider from faker.providers.person.sv_SE import Provider as SvSEProvider from faker.providers.person.cs_CZ import Provider as CsCZProvider +from faker.providers.person.pl_PL import Provider as PlPLProvider from faker.providers.person.pl_PL import ( checksum_identity_card_number as pl_checksum_identity_card_number, - checksum_pesel_number as pl_checksum_pesel_number, ) from faker.providers.person.zh_CN import Provider as ZhCNProvider from faker.providers.person.zh_TW import Provider as ZhTWProvider @@ -207,13 +212,43 @@ def test_identity_card_number(self): for _ in range(100): assert re.search(r'^[A-Z]{3}\d{6}$', self.factory.identity_card_number()) - def test_pesel_number_checksum(self): - assert pl_checksum_pesel_number('31090655159') is True - assert pl_checksum_pesel_number('95030853577') is True - assert pl_checksum_pesel_number('05260953442') is True - assert pl_checksum_pesel_number('31090655158') is False - assert pl_checksum_pesel_number('95030853576') is False - assert pl_checksum_pesel_number('05260953441') is False + @mock.patch.object(PlPLProvider, 'random_digit') + def test_pesel_birth_date(self, mock_random_digit): + mock_random_digit.side_effect = [3, 5, 8, 8, 7, 9, 9, 3] + assert self.factory.pesel(datetime.date(1999, 12, 31)) == '99123135885' + assert self.factory.pesel(datetime.date(2000, 1, 1)) == '00210179936' + + @mock.patch.object(PlPLProvider, 'random_digit') + def test_pesel_sex_male(self, mock_random_digit): + mock_random_digit.side_effect = [1, 3, 4, 5, 6, 1, 7, 0] + assert self.factory.pesel(datetime.date(1909, 3, 3), 'M') == '09030313454' + assert self.factory.pesel(datetime.date(1913, 8, 16), 'M') == '13081661718' + + @mock.patch.object(PlPLProvider, 'random_digit') + def test_pesel_sex_female(self, mock_random_digit): + mock_random_digit.side_effect = [4, 9, 1, 6, 6, 1, 7, 3] + assert self.factory.pesel(datetime.date(2007, 4, 13), 'F') == '07241349161' + assert self.factory.pesel(datetime.date(1933, 12, 16), 'F') == '33121661744' + + @mock.patch.object(PlPLProvider, 'random_digit') + def test_pwz_doctor(self, mock_random_digit): + mock_random_digit.side_effect = [6, 9, 1, 9, 6, 5, 2, 7, 9, 9, 1, 5] + assert self.factory.pwz_doctor() == '2691965' + assert self.factory.pwz_doctor() == '4279915' + + @mock.patch.object(PlPLProvider, 'random_digit') + def test_pwz_doctor_check_digit_zero(self, mock_random_digit): + mock_random_digit.side_effect = [0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 9, 9] + assert self.factory.pwz_doctor() == '6000012' + assert self.factory.pwz_doctor() == '1000090' + + @mock.patch.object(PlPLProvider, 'random_int') + @mock.patch.object(PlPLProvider, 'random_digit') + def test_pwz_nurse(self, mock_random_digit, mock_random_int): + mock_random_digit.side_effect = [3, 4, 5, 6, 7, 1, 7, 5, 1, 2] + mock_random_int.side_effect = [45, 3] + assert self.factory.pwz_nurse(kind='nurse') == '4534567P' + assert self.factory.pwz_nurse(kind='midwife') == '0317512A' class TestCsCZ(unittest.TestCase):

[ { "components": [ { "doc": "", "lines": [ 707, 709 ], "name": "Provider.pesel_compute_check_digit", "signature": "def pesel_compute_check_digit(pesel):", "type": "function" }, { "doc": "", "lines": [ ...

[ "tests/providers/test_person.py::TestPlPL::test_pesel_birth_date", "tests/providers/test_person.py::TestPlPL::test_pesel_sex_female", "tests/providers/test_person.py::TestPlPL::test_pesel_sex_male", "tests/providers/test_person.py::TestPlPL::test_pwz_doctor", "tests/providers/test_person.py::TestPlPL::test_...

[ "tests/providers/test_person.py::TestAr::test_first_name", "tests/providers/test_person.py::TestAr::test_last_name", "tests/providers/test_person.py::TestJaJP::test_person", "tests/providers/test_person.py::TestNeNP::test_names", "tests/providers/test_person.py::TestFiFI::test_gender_first_names", "tests/...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> add pwz generator and date_of_brith and sex asargument to pesel (`pl_PL`) What does this changes - `Person` in `pl_PL` What was wrong - it wasn't possible to generate pesel number for given date of birth and/or sex - generator for a `pwz` number was unavailable How this fixes it - adds pwz_doctor and pwz_nurse generator to `Person` (pl_PL) - adds date_of_birth and sex as parameter to `Person.pesel` (pl_PL) Fixes #931 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/person/pl_PL/__init__.py] (definition of Provider.pesel_compute_check_digit:) def pesel_compute_check_digit(pesel): (definition of Provider.pwz_doctor_compute_check_digit:) def pwz_doctor_compute_check_digit(x): (definition of Provider.pwz_doctor:) def pwz_doctor(self): """Function generates an identification number for medical doctors Polish: Prawo Wykonywania Zawodu (PWZ) https://www.nil.org.pl/rejestry/centralny-rejestr-lekarzy/zasady-weryfikowania-nr-prawa-wykonywania-zawodu""" (definition of Provider.pwz_nurse:) def pwz_nurse(self, kind='nurse'): """Function generates an identification number for nurses and midwives Polish: Prawo Wykonywania Zawodu (PWZ) http://arch.nipip.pl/index.php/prawo/uchwaly/naczelnych-rad/w-roku-2015/posiedzenie-15-17-grudnia/3664-uchwala- nr-381-vi-2015-w-sprawie-trybu-postepowania-dotyczacego-stwierdzania-i-przyznawania-prawa-wykonywania-zawodu-pi elegniarki-i-zawodu-poloznej-oraz-sposobu-prowadzenia-rejestru-pielegniarek-i-rejestru-poloznych-przez-okregowe -rady-pielegniarek-i-polo""" [end of new definitions in faker/providers/person/pl_PL/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> pl_PL tasks - a lot of things to add Hi, I'm using faker quite often, but there is some missing functionalities for pl_PL, like e.g. PESEL generator (Polish id for every person), car plates or some more. Can I contribute on my own branch (e.g. pl-PL-features or something), to add missing functionalities? ---------- Hi @adwojak , Thank for reaching out! Feel free to fork the repo, create your branch and submit Pull Requests! Thanks a lot! -------------------- </issues>

6edfdbf6ae90b0153309e3bf066aa3b2d16494a7

scrapy__scrapy-3796

3,796

scrapy/scrapy

null

a3d38041e230f886d55569f861a11a96ab8a1913

2019-05-27T06:17:15Z

diff --git a/.travis.yml b/.travis.yml index 08b0bf1195c..dc333a2012d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -26,6 +26,12 @@ matrix: sudo: true - python: 3.6 env: TOXENV=docs + - python: 3.7 + env: TOXENV=py37-extra-deps + dist: xenial + sudo: true + - python: 2.7 + env: TOXENV=py27-extra-deps install: - | if [ "$TOXENV" = "pypy" ]; then diff --git a/docs/topics/downloader-middleware.rst b/docs/topics/downloader-middleware.rst index f2f3ef46657..ae1086ee10e 100644 --- a/docs/topics/downloader-middleware.rst +++ b/docs/topics/downloader-middleware.rst @@ -922,6 +922,17 @@ RobotsTxtMiddleware To make sure Scrapy respects robots.txt make sure the middleware is enabled and the :setting:`ROBOTSTXT_OBEY` setting is enabled. + This middleware has to be combined with a robots.txt_ parser. + + Scrapy ships with support for the following robots.txt_ parsers: + + * :ref:`RobotFileParser <python-robotfileparser>` (default) + * :ref:`Reppy <reppy-parser>` + * :ref:`Robotexclusionrulesparser <rerp-parser>` + + You can change the robots.txt_ parser with the :setting:`ROBOTSTXT_PARSER` + setting. Or you can also :ref:`implement support for a new parser <support-for-new-robots-parser>`. + .. reqmeta:: dont_obey_robotstxt If :attr:`Request.meta <scrapy.http.Request.meta>` has @@ -929,6 +940,74 @@ If :attr:`Request.meta <scrapy.http.Request.meta>` has the request will be ignored by this middleware even if :setting:`ROBOTSTXT_OBEY` is enabled. +.. _python-robotfileparser: + +RobotFileParser +~~~~~~~~~~~~~~~ + +`RobotFileParser <https://docs.python.org/3.7/library/urllib.robotparser.html>`_ is +Python's inbuilt ``robots.txt`` parser. The parser is fully compliant with `Martijn Koster's +1996 draft specification <http://www.robotstxt.org/norobots-rfc.txt>`_. It lacks +support for wildcard matching. Scrapy uses this parser by default. + +In order to use this parser, set: + +* :setting:`ROBOTSTXT_PARSER` to ``scrapy.robotstxt.PythonRobotParser`` + +.. _rerp-parser: + +Robotexclusionrulesparser +~~~~~~~~~~~~~~~~~~~~~~~~~ + +`Robotexclusionrulesparser <http://nikitathespider.com/python/rerp/>`_ is fully compliant +with `Martijn Koster's 1996 draft specification <http://www.robotstxt.org/norobots-rfc.txt>`_, +with support for wildcard matching. + +In order to use this parser: + +* Install `Robotexclusionrulesparser <http://nikitathespider.com/python/rerp/>`_ by running + ``pip install robotexclusionrulesparser`` + +* Set :setting:`ROBOTSTXT_PARSER` setting to + ``scrapy.robotstxt.RerpRobotParser`` + +.. _reppy-parser: + +Reppy parser +~~~~~~~~~~~~ + +`Reppy <https://github.com/seomoz/reppy/>`_ is a Python wrapper around `Robots Exclusion +Protocol Parser for C++ <https://github.com/seomoz/rep-cpp>`_. The parser is fully compliant +with `Martijn Koster's 1996 draft specification <http://www.robotstxt.org/norobots-rfc.txt>`_, +with support for wildcard matching. Unlike +`RobotFileParser <https://docs.python.org/3.7/library/urllib.robotparser.html>`_ and +`Robotexclusionrulesparser <http://nikitathespider.com/python/rerp/>`_, it uses the length based +rule, in particular for ``Allow`` and ``Disallow`` directives, where the most specific +rule based on the length of the path trumps the less specific (shorter) rule. + +In order to use this parser: + +* Install `Reppy <https://github.com/seomoz/reppy/>`_ by running ``pip install reppy`` + +* Set :setting:`ROBOTSTXT_PARSER` setting to + ``scrapy.robotstxt.ReppyRobotParser`` + +.. _support-for-new-robots-parser: + +Implementing support for a new parser +------------------------------------- + +You can implement support for a new robots.txt_ parser by subclassing +the abstract base class :class:`~scrapy.robotstxt.RobotParser` and +implementing the methods described below. + +.. module:: scrapy.robotstxt + :synopsis: robots.txt parser interface and implementations + +.. autoclass:: RobotParser + :members: + +.. _robots.txt: http://www.robotstxt.org/ DownloaderStats --------------- diff --git a/docs/topics/settings.rst b/docs/topics/settings.rst index 371f21c72f5..0d3eaa094c8 100644 --- a/docs/topics/settings.rst +++ b/docs/topics/settings.rst @@ -1113,6 +1113,16 @@ If enabled, Scrapy will respect robots.txt policies. For more information see this option is enabled by default in settings.py file generated by ``scrapy startproject`` command. +.. setting:: ROBOTSTXT_PARSER + +ROBOTSTXT_PARSER +---------------- + +Default: ``'scrapy.robotstxt.PythonRobotParser'`` + +The parser backend to use for parsing ``robots.txt`` files. For more information see +:ref:`topics-dlmw-robots`. + .. setting:: SCHEDULER SCHEDULER diff --git a/scrapy/downloadermiddlewares/robotstxt.py b/scrapy/downloadermiddlewares/robotstxt.py index 200245210ec..c5a60d355e2 100644 --- a/scrapy/downloadermiddlewares/robotstxt.py +++ b/scrapy/downloadermiddlewares/robotstxt.py @@ -5,8 +5,8 @@ """ import logging - -from six.moves.urllib import robotparser +import sys +import re from twisted.internet.defer import Deferred, maybeDeferred from scrapy.exceptions import NotConfigured, IgnoreRequest @@ -14,6 +14,7 @@ from scrapy.utils.httpobj import urlparse_cached from scrapy.utils.log import failure_to_exc_info from scrapy.utils.python import to_native_str +from scrapy.utils.misc import load_object logger = logging.getLogger(__name__) @@ -24,10 +25,13 @@ class RobotsTxtMiddleware(object): def __init__(self, crawler): if not crawler.settings.getbool('ROBOTSTXT_OBEY'): raise NotConfigured - + self._default_useragent = crawler.settings.get('USER_AGENT', 'Scrapy') self.crawler = crawler - self._useragent = crawler.settings.get('USER_AGENT') self._parsers = {} + self._parserimpl = load_object(crawler.settings.get('ROBOTSTXT_PARSER')) + + # check if parser dependencies are met, this should throw an error otherwise. + self._parserimpl.from_crawler(self.crawler, b'') @classmethod def from_crawler(cls, crawler): @@ -43,7 +47,8 @@ def process_request(self, request, spider): def process_request_2(self, rp, request, spider): if rp is None: return - if not rp.can_fetch(to_native_str(self._useragent), request.url): + useragent = request.headers.get(b'User-Agent', self._default_useragent) + if not rp.allowed(request.url, useragent): logger.debug("Forbidden by robots.txt: %(request)s", {'request': request}, extra={'spider': spider}) self.crawler.stats.inc_value('robotstxt/forbidden') @@ -62,13 +67,14 @@ def robot_parser(self, request, spider): meta={'dont_obey_robotstxt': True} ) dfd = self.crawler.engine.download(robotsreq, spider) - dfd.addCallback(self._parse_robots, netloc) + dfd.addCallback(self._parse_robots, netloc, spider) dfd.addErrback(self._logerror, robotsreq, spider) dfd.addErrback(self._robots_error, netloc) self.crawler.stats.inc_value('robotstxt/request_count') if isinstance(self._parsers[netloc], Deferred): d = Deferred() + def cb(result): d.callback(result) return result @@ -85,27 +91,10 @@ def _logerror(self, failure, request, spider): extra={'spider': spider}) return failure - def _parse_robots(self, response, netloc): + def _parse_robots(self, response, netloc, spider): self.crawler.stats.inc_value('robotstxt/response_count') - self.crawler.stats.inc_value( - 'robotstxt/response_status_count/{}'.format(response.status)) - rp = robotparser.RobotFileParser(response.url) - body = '' - if hasattr(response, 'text'): - body = response.text - else: # last effort try - try: - body = response.body.decode('utf-8') - except UnicodeDecodeError: - # If we found garbage, disregard it:, - # but keep the lookup cached (in self._parsers) - # Running rp.parse() will set rp state from - # 'disallow all' to 'allow any'. - self.crawler.stats.inc_value('robotstxt/unicode_error_count') - # stdlib's robotparser expects native 'str' ; - # with unicode input, non-ASCII encoded bytes decoding fails in Python2 - rp.parse(to_native_str(body).splitlines()) - + self.crawler.stats.inc_value('robotstxt/response_status_count/{}'.format(response.status)) + rp = self._parserimpl.from_crawler(self.crawler, response.body) rp_dfd = self._parsers[netloc] self._parsers[netloc] = rp rp_dfd.callback(rp) diff --git a/scrapy/robotstxt.py b/scrapy/robotstxt.py new file mode 100644 index 00000000000..4bfb275fdcd --- /dev/null +++ b/scrapy/robotstxt.py @@ -0,0 +1,112 @@ +import sys +import logging +from abc import ABCMeta, abstractmethod +from six import with_metaclass + +from scrapy.utils.python import to_native_str, to_unicode + +logger = logging.getLogger(__name__) + + +class RobotParser(with_metaclass(ABCMeta)): + @classmethod + @abstractmethod + def from_crawler(cls, crawler, robotstxt_body): + """Parse the content of a robots.txt_ file as bytes. This must be a class method. + It must return a new instance of the parser backend. + + :param crawler: crawler which made the request + :type crawler: :class:`~scrapy.crawler.Crawler` instance + + :param robotstxt_body: content of a robots.txt_ file. + :type robotstxt_body: bytes + """ + pass + + @abstractmethod + def allowed(self, url, user_agent): + """Return ``True`` if ``user_agent`` is allowed to crawl ``url``, otherwise return ``False``. + + :param url: Absolute URL + :type url: string + + :param user_agent: User agent + :type user_agent: string + """ + pass + + +class PythonRobotParser(RobotParser): + def __init__(self, robotstxt_body, spider): + from six.moves.urllib_robotparser import RobotFileParser + self.spider = spider + try: + robotstxt_body = to_native_str(robotstxt_body) + except UnicodeDecodeError: + # If we found garbage or robots.txt in an encoding other than UTF-8, disregard it. + # Switch to 'allow all' state. + logger.warning("Failure while parsing robots.txt using %(parser)s." + " File either contains garbage or is in an encoding other than UTF-8, treating it as an empty file.", + {'parser': "RobotFileParser"}, + exc_info=sys.exc_info(), + extra={'spider': self.spider}) + robotstxt_body = '' + self.rp = RobotFileParser() + self.rp.parse(robotstxt_body.splitlines()) + + @classmethod + def from_crawler(cls, crawler, robotstxt_body): + spider = None if not crawler else crawler.spider + o = cls(robotstxt_body, spider) + return o + + def allowed(self, url, user_agent): + user_agent = to_native_str(user_agent) + url = to_native_str(url) + return self.rp.can_fetch(user_agent, url) + + +class ReppyRobotParser(RobotParser): + def __init__(self, robotstxt_body, spider): + from reppy.robots import Robots + self.spider = spider + self.rp = Robots.parse('', robotstxt_body) + + @classmethod + def from_crawler(cls, crawler, robotstxt_body): + spider = None if not crawler else crawler.spider + o = cls(robotstxt_body, spider) + return o + + def allowed(self, url, user_agent): + return self.rp.allowed(url, user_agent) + + +class RerpRobotParser(RobotParser): + def __init__(self, robotstxt_body, spider): + from robotexclusionrulesparser import RobotExclusionRulesParser + self.spider = spider + self.rp = RobotExclusionRulesParser() + try: + robotstxt_body = robotstxt_body.decode('utf-8') + except UnicodeDecodeError: + # If we found garbage or robots.txt in an encoding other than UTF-8, disregard it. + # Switch to 'allow all' state. + logger.warning("Failure while parsing robots.txt using %(parser)s." + " File either contains garbage or is in an encoding other than UTF-8, treating it as an empty file.", + {'parser': "RobotExclusionRulesParser"}, + exc_info=sys.exc_info(), + extra={'spider': self.spider}) + robotstxt_body = '' + self.rp.parse(robotstxt_body) + + @classmethod + def from_crawler(cls, crawler, robotstxt_body): + spider = None if not crawler else crawler.spider + o = cls(robotstxt_body, spider) + return o + + def allowed(self, url, user_agent): + user_agent = to_unicode(user_agent) + url = to_unicode(url) + return self.rp.is_allowed(user_agent, url) diff --git a/scrapy/settings/default_settings.py b/scrapy/settings/default_settings.py index 9986827d82e..31e92bd712f 100644 --- a/scrapy/settings/default_settings.py +++ b/scrapy/settings/default_settings.py @@ -242,6 +242,7 @@ RETRY_PRIORITY_ADJUST = -1 ROBOTSTXT_OBEY = False +ROBOTSTXT_PARSER = 'scrapy.robotstxt.PythonRobotParser' SCHEDULER = 'scrapy.core.scheduler.Scheduler' SCHEDULER_DISK_QUEUE = 'scrapy.squeues.PickleLifoDiskQueue' diff --git a/tox.ini b/tox.ini index 0c0f8f7b7d5..a9cef9b90d0 100644 --- a/tox.ini +++ b/tox.ini @@ -110,3 +110,17 @@ changedir = {[docs]changedir} deps = {[docs]deps} commands = sphinx-build -W -b linkcheck . {envtmpdir}/linkcheck + +[testenv:py37-extra-deps] +basepython = python3.7 +deps = + {[testenv:py34]deps} + reppy + robotexclusionrulesparser + +[testenv:py27-extra-deps] +basepython = python2.7 +deps = + {[testenv]deps} + reppy + robotexclusionrulesparser

diff --git a/tests/test_downloadermiddleware_robotstxt.py b/tests/test_downloadermiddleware_robotstxt.py index 60306eacb84..816f88ca15c 100644 --- a/tests/test_downloadermiddleware_robotstxt.py +++ b/tests/test_downloadermiddleware_robotstxt.py @@ -11,6 +11,7 @@ from scrapy.http import Request, Response, TextResponse from scrapy.settings import Settings from tests import mock +from tests.test_robotstxt_interface import rerp_available, reppy_available class RobotsTxtMiddlewareTest(unittest.TestCase): @@ -44,6 +45,7 @@ def _get_successful_crawler(self): Disallow: /some/randome/page.html '''.encode('utf-8')) response = TextResponse('http://site.local/robots.txt', body=ROBOTS) + def return_response(request, spider): deferred = Deferred() reactor.callFromThread(deferred.callback, response) @@ -80,6 +82,7 @@ def _get_garbage_crawler(self): crawler = self.crawler crawler.settings.set('ROBOTSTXT_OBEY', True) response = Response('http://site.local/robots.txt', body=b'GIF89a\xd3\x00\xfe\x00\xa2') + def return_response(request, spider): deferred = Deferred() reactor.callFromThread(deferred.callback, response) @@ -102,6 +105,7 @@ def _get_emptybody_crawler(self): crawler = self.crawler crawler.settings.set('ROBOTSTXT_OBEY', True) response = Response('http://site.local/robots.txt') + def return_response(request, spider): deferred = Deferred() reactor.callFromThread(deferred.callback, response) @@ -121,6 +125,7 @@ def test_robotstxt_empty_response(self): def test_robotstxt_error(self): self.crawler.settings.set('ROBOTSTXT_OBEY', True) err = error.DNSLookupError('Robotstxt address not found') + def return_failure(request, spider): deferred = Deferred() reactor.callFromThread(deferred.errback, failure.Failure(err)) @@ -136,6 +141,7 @@ def return_failure(request, spider): def test_robotstxt_immediate_error(self): self.crawler.settings.set('ROBOTSTXT_OBEY', True) err = error.DNSLookupError('Robotstxt address not found') + def immediate_failure(request, spider): deferred = Deferred() deferred.errback(failure.Failure(err)) @@ -147,6 +153,7 @@ def immediate_failure(request, spider): def test_ignore_robotstxt_request(self): self.crawler.settings.set('ROBOTSTXT_OBEY', True) + def ignore_request(request, spider): deferred = Deferred() reactor.callFromThread(deferred.errback, failure.Failure(IgnoreRequest())) @@ -170,3 +177,21 @@ def assertIgnored(self, request, middleware): spider = None # not actually used return self.assertFailure(maybeDeferred(middleware.process_request, request, spider), IgnoreRequest) + + +class RobotsTxtMiddlewareWithRerpTest(RobotsTxtMiddlewareTest): + if not rerp_available(): + skip = "Rerp parser is not installed" + + def setUp(self): + super(RobotsTxtMiddlewareWithRerpTest, self).setUp() + self.crawler.settings.set('ROBOTSTXT_PARSER', 'scrapy.robotstxt.RerpRobotParser') + + +class RobotsTxtMiddlewareWithReppyTest(RobotsTxtMiddlewareTest): + if not reppy_available(): + skip = "Reppy parser is not installed" + + def setUp(self): + super(RobotsTxtMiddlewareWithReppyTest, self).setUp() + self.crawler.settings.set('ROBOTSTXT_PARSER', 'scrapy.robotstxt.ReppyRobotParser') diff --git a/tests/test_robotstxt_interface.py b/tests/test_robotstxt_interface.py new file mode 100644 index 00000000000..2819786b531 --- /dev/null +++ b/tests/test_robotstxt_interface.py @@ -0,0 +1,142 @@ +# coding=utf-8 +from twisted.trial import unittest +from scrapy.utils.python import to_native_str + + +def reppy_available(): + # check if reppy parser is installed + try: + from reppy.robots import Robots + except ImportError: + return False + return True + + +def rerp_available(): + # check if robotexclusionrulesparser is installed + try: + from robotexclusionrulesparser import RobotExclusionRulesParser + except ImportError: + return False + return True + + +class BaseRobotParserTest: + def _setUp(self, parser_cls): + self.parser_cls = parser_cls + + def test_allowed(self): + robotstxt_robotstxt_body = ("User-agent: * \n" + "Disallow: /disallowed \n" + "Allow: /allowed \n" + "Crawl-delay: 10".encode('utf-8')) + rp = self.parser_cls.from_crawler(crawler=None, robotstxt_body=robotstxt_robotstxt_body) + self.assertTrue(rp.allowed("https://www.site.local/allowed", "*")) + self.assertFalse(rp.allowed("https://www.site.local/disallowed", "*")) + + def test_allowed_wildcards(self): + robotstxt_robotstxt_body = """User-agent: first + Disallow: /disallowed/*/end$ + + User-agent: second + Allow: /*allowed + Disallow: / + """.encode('utf-8') + rp = self.parser_cls.from_crawler(crawler=None, robotstxt_body=robotstxt_robotstxt_body) + + self.assertTrue(rp.allowed("https://www.site.local/disallowed", "first")) + self.assertFalse(rp.allowed("https://www.site.local/disallowed/xyz/end", "first")) + self.assertFalse(rp.allowed("https://www.site.local/disallowed/abc/end", "first")) + self.assertTrue(rp.allowed("https://www.site.local/disallowed/xyz/endinglater", "first")) + + self.assertTrue(rp.allowed("https://www.site.local/allowed", "second")) + self.assertTrue(rp.allowed("https://www.site.local/is_still_allowed", "second")) + self.assertTrue(rp.allowed("https://www.site.local/is_allowed_too", "second")) + + def test_length_based_precedence(self): + robotstxt_robotstxt_body = ("User-agent: * \n" + "Disallow: / \n" + "Allow: /page".encode('utf-8')) + rp = self.parser_cls.from_crawler(crawler=None, robotstxt_body=robotstxt_robotstxt_body) + self.assertTrue(rp.allowed("https://www.site.local/page", "*")) + + def test_order_based_precedence(self): + robotstxt_robotstxt_body = ("User-agent: * \n" + "Disallow: / \n" + "Allow: /page".encode('utf-8')) + rp = self.parser_cls.from_crawler(crawler=None, robotstxt_body=robotstxt_robotstxt_body) + self.assertFalse(rp.allowed("https://www.site.local/page", "*")) + + def test_empty_response(self): + """empty response should equal 'allow all'""" + rp = self.parser_cls.from_crawler(crawler=None, robotstxt_body=b'') + self.assertTrue(rp.allowed("https://site.local/", "*")) + self.assertTrue(rp.allowed("https://site.local/", "chrome")) + self.assertTrue(rp.allowed("https://site.local/index.html", "*")) + self.assertTrue(rp.allowed("https://site.local/disallowed", "*")) + + def test_garbage_response(self): + """garbage response should be discarded, equal 'allow all'""" + robotstxt_robotstxt_body = b'GIF89a\xd3\x00\xfe\x00\xa2' + rp = self.parser_cls.from_crawler(crawler=None, robotstxt_body=robotstxt_robotstxt_body) + self.assertTrue(rp.allowed("https://site.local/", "*")) + self.assertTrue(rp.allowed("https://site.local/", "chrome")) + self.assertTrue(rp.allowed("https://site.local/index.html", "*")) + self.assertTrue(rp.allowed("https://site.local/disallowed", "*")) + + def test_unicode_url_and_useragent(self): + robotstxt_robotstxt_body = u""" + User-Agent: * + Disallow: /admin/ + Disallow: /static/ + # taken from https://en.wikipedia.org/robots.txt + Disallow: /wiki/K%C3%A4ytt%C3%A4j%C3%A4: + Disallow: /wiki/Käyttäjä: + + User-Agent: UnicödeBöt + Disallow: /some/randome/page.html""".encode('utf-8') + rp = self.parser_cls.from_crawler(crawler=None, robotstxt_body=robotstxt_robotstxt_body) + self.assertTrue(rp.allowed("https://site.local/", "*")) + self.assertFalse(rp.allowed("https://site.local/admin/", "*")) + self.assertFalse(rp.allowed("https://site.local/static/", "*")) + self.assertTrue(rp.allowed("https://site.local/admin/", u"UnicödeBöt")) + self.assertFalse(rp.allowed("https://site.local/wiki/K%C3%A4ytt%C3%A4j%C3%A4:", "*")) + self.assertFalse(rp.allowed(u"https://site.local/wiki/Käyttäjä:", "*")) + self.assertTrue(rp.allowed("https://site.local/some/randome/page.html", "*")) + self.assertFalse(rp.allowed("https://site.local/some/randome/page.html", u"UnicödeBöt")) + + +class PythonRobotParserTest(BaseRobotParserTest, unittest.TestCase): + def setUp(self): + from scrapy.robotstxt import PythonRobotParser + super(PythonRobotParserTest, self)._setUp(PythonRobotParser) + + def test_length_based_precedence(self): + raise unittest.SkipTest("RobotFileParser does not support length based directives precedence.") + + def test_allowed_wildcards(self): + raise unittest.SkipTest("RobotFileParser does not support wildcards.") + + +class ReppyRobotParserTest(BaseRobotParserTest, unittest.TestCase): + if not reppy_available(): + skip = "Reppy parser is not installed" + + def setUp(self): + from scrapy.robotstxt import ReppyRobotParser + super(ReppyRobotParserTest, self)._setUp(ReppyRobotParser) + + def test_order_based_precedence(self): + raise unittest.SkipTest("Rerp does not support order based directives precedence.") + + +class RerpRobotParserTest(BaseRobotParserTest, unittest.TestCase): + if not rerp_available(): + skip = "Rerp parser is not installed" + + def setUp(self): + from scrapy.robotstxt import RerpRobotParser + super(RerpRobotParserTest, self)._setUp(RerpRobotParser) + + def test_length_based_precedence(self): + raise unittest.SkipTest("Rerp does not support length based directives precedence.")

diff --git a/.travis.yml b/.travis.yml index 08b0bf1195c..dc333a2012d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -26,6 +26,12 @@ matrix: sudo: true - python: 3.6 env: TOXENV=docs + - python: 3.7 + env: TOXENV=py37-extra-deps + dist: xenial + sudo: true + - python: 2.7 + env: TOXENV=py27-extra-deps install: - | if [ "$TOXENV" = "pypy" ]; then diff --git a/docs/topics/downloader-middleware.rst b/docs/topics/downloader-middleware.rst index f2f3ef46657..ae1086ee10e 100644 --- a/docs/topics/downloader-middleware.rst +++ b/docs/topics/downloader-middleware.rst @@ -922,6 +922,17 @@ RobotsTxtMiddleware To make sure Scrapy respects robots.txt make sure the middleware is enabled and the :setting:`ROBOTSTXT_OBEY` setting is enabled. + This middleware has to be combined with a robots.txt_ parser. + + Scrapy ships with support for the following robots.txt_ parsers: + + * :ref:`RobotFileParser <python-robotfileparser>` (default) + * :ref:`Reppy <reppy-parser>` + * :ref:`Robotexclusionrulesparser <rerp-parser>` + + You can change the robots.txt_ parser with the :setting:`ROBOTSTXT_PARSER` + setting. Or you can also :ref:`implement support for a new parser <support-for-new-robots-parser>`. + .. reqmeta:: dont_obey_robotstxt If :attr:`Request.meta <scrapy.http.Request.meta>` has @@ -929,6 +940,74 @@ If :attr:`Request.meta <scrapy.http.Request.meta>` has the request will be ignored by this middleware even if :setting:`ROBOTSTXT_OBEY` is enabled. +.. _python-robotfileparser: + +RobotFileParser +~~~~~~~~~~~~~~~ + +`RobotFileParser <https://docs.python.org/3.7/library/urllib.robotparser.html>`_ is +Python's inbuilt ``robots.txt`` parser. The parser is fully compliant with `Martijn Koster's +1996 draft specification <http://www.robotstxt.org/norobots-rfc.txt>`_. It lacks +support for wildcard matching. Scrapy uses this parser by default. + +In order to use this parser, set: + +* :setting:`ROBOTSTXT_PARSER` to ``scrapy.robotstxt.PythonRobotParser`` + +.. _rerp-parser: + +Robotexclusionrulesparser +~~~~~~~~~~~~~~~~~~~~~~~~~ + +`Robotexclusionrulesparser <http://nikitathespider.com/python/rerp/>`_ is fully compliant +with `Martijn Koster's 1996 draft specification <http://www.robotstxt.org/norobots-rfc.txt>`_, +with support for wildcard matching. + +In order to use this parser: + +* Install `Robotexclusionrulesparser <http://nikitathespider.com/python/rerp/>`_ by running + ``pip install robotexclusionrulesparser`` + +* Set :setting:`ROBOTSTXT_PARSER` setting to + ``scrapy.robotstxt.RerpRobotParser`` + +.. _reppy-parser: + +Reppy parser +~~~~~~~~~~~~ + +`Reppy <https://github.com/seomoz/reppy/>`_ is a Python wrapper around `Robots Exclusion +Protocol Parser for C++ <https://github.com/seomoz/rep-cpp>`_. The parser is fully compliant +with `Martijn Koster's 1996 draft specification <http://www.robotstxt.org/norobots-rfc.txt>`_, +with support for wildcard matching. Unlike +`RobotFileParser <https://docs.python.org/3.7/library/urllib.robotparser.html>`_ and +`Robotexclusionrulesparser <http://nikitathespider.com/python/rerp/>`_, it uses the length based +rule, in particular for ``Allow`` and ``Disallow`` directives, where the most specific +rule based on the length of the path trumps the less specific (shorter) rule. + +In order to use this parser: + +* Install `Reppy <https://github.com/seomoz/reppy/>`_ by running ``pip install reppy`` + +* Set :setting:`ROBOTSTXT_PARSER` setting to + ``scrapy.robotstxt.ReppyRobotParser`` + +.. _support-for-new-robots-parser: + +Implementing support for a new parser +------------------------------------- + +You can implement support for a new robots.txt_ parser by subclassing +the abstract base class :class:`~scrapy.robotstxt.RobotParser` and +implementing the methods described below. + +.. module:: scrapy.robotstxt + :synopsis: robots.txt parser interface and implementations + +.. autoclass:: RobotParser + :members: + +.. _robots.txt: http://www.robotstxt.org/ DownloaderStats --------------- diff --git a/docs/topics/settings.rst b/docs/topics/settings.rst index 371f21c72f5..0d3eaa094c8 100644 --- a/docs/topics/settings.rst +++ b/docs/topics/settings.rst @@ -1113,6 +1113,16 @@ If enabled, Scrapy will respect robots.txt policies. For more information see this option is enabled by default in settings.py file generated by ``scrapy startproject`` command. +.. setting:: ROBOTSTXT_PARSER + +ROBOTSTXT_PARSER +---------------- + +Default: ``'scrapy.robotstxt.PythonRobotParser'`` + +The parser backend to use for parsing ``robots.txt`` files. For more information see +:ref:`topics-dlmw-robots`. + .. setting:: SCHEDULER SCHEDULER diff --git a/tox.ini b/tox.ini index 0c0f8f7b7d5..a9cef9b90d0 100644 --- a/tox.ini +++ b/tox.ini @@ -110,3 +110,17 @@ changedir = {[docs]changedir} deps = {[docs]deps} commands = sphinx-build -W -b linkcheck . {envtmpdir}/linkcheck + +[testenv:py37-extra-deps] +basepython = python3.7 +deps = + {[testenv:py34]deps} + reppy + robotexclusionrulesparser + +[testenv:py27-extra-deps] +basepython = python2.7 +deps = + {[testenv]deps} + reppy + robotexclusionrulesparser

[ { "components": [ { "doc": "", "lines": [ 11, 36 ], "name": "RobotParser", "signature": "class RobotParser(with_metaclass(ABCMeta)): @classmethod @abstractmethod", "type": "class" }, { "doc": "Parse the content of a ro...

[ "tests/test_robotstxt_interface.py::PythonRobotParserTest::test_allowed", "tests/test_robotstxt_interface.py::PythonRobotParserTest::test_empty_response", "tests/test_robotstxt_interface.py::PythonRobotParserTest::test_garbage_response", "tests/test_robotstxt_interface.py::PythonRobotParserTest::test_order_ba...

[ "tests/test_downloadermiddleware_robotstxt.py::RobotsTxtMiddlewareTest::test_ignore_robotstxt_request", "tests/test_downloadermiddleware_robotstxt.py::RobotsTxtMiddlewareTest::test_robotstxt", "tests/test_downloadermiddleware_robotstxt.py::RobotsTxtMiddlewareTest::test_robotstxt_empty_response", "tests/test_d...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG+1] [GSoC 2019] Interface for robots.txt parsers [For Google Summer of Code 2019] This pull request is not ready for merging. Looking for reviews and suggestions. Excited for the awesome summer ahead. :) @Gallaecio @whalebot-helmsman Will there be any benefit from using python's abc library for creating `BaseRobotsTxtParser` class here? ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in scrapy/robotstxt.py] (definition of RobotParser:) class RobotParser(with_metaclass(ABCMeta)): @classmethod @abstractmethod (definition of RobotParser.from_crawler:) def from_crawler(cls, crawler, robotstxt_body): """Parse the content of a robots.txt_ file as bytes. This must be a class method. It must return a new instance of the parser backend. :param crawler: crawler which made the request :type crawler: :class:`~scrapy.crawler.Crawler` instance :param robotstxt_body: content of a robots.txt_ file. :type robotstxt_body: bytes""" (definition of RobotParser.allowed:) def allowed(self, url, user_agent): """Return ``True`` if ``user_agent`` is allowed to crawl ``url``, otherwise return ``False``. :param url: Absolute URL :type url: string :param user_agent: User agent :type user_agent: string""" (definition of PythonRobotParser:) class PythonRobotParser(RobotParser): (definition of PythonRobotParser.__init__:) def __init__(self, robotstxt_body, spider): (definition of PythonRobotParser.from_crawler:) def from_crawler(cls, crawler, robotstxt_body): (definition of PythonRobotParser.allowed:) def allowed(self, url, user_agent): (definition of ReppyRobotParser:) class ReppyRobotParser(RobotParser): (definition of ReppyRobotParser.__init__:) def __init__(self, robotstxt_body, spider): (definition of ReppyRobotParser.from_crawler:) def from_crawler(cls, crawler, robotstxt_body): (definition of ReppyRobotParser.allowed:) def allowed(self, url, user_agent): (definition of RerpRobotParser:) class RerpRobotParser(RobotParser): (definition of RerpRobotParser.__init__:) def __init__(self, robotstxt_body, spider): (definition of RerpRobotParser.from_crawler:) def from_crawler(cls, crawler, robotstxt_body): (definition of RerpRobotParser.allowed:) def allowed(self, url, user_agent): [end of new definitions in scrapy/robotstxt.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

57a5460529ff71c42e4d0381265b1b512b1eb09b

sympy__sympy-16896

16,896

sympy/sympy

1.5

8e23c8091c4c60a4479a23c78bac1ee535adbcdc

2019-05-26T12:56:25Z

diff --git a/sympy/calculus/util.py b/sympy/calculus/util.py index 4c8a2559d051..90fce092429f 100644 --- a/sympy/calculus/util.py +++ b/sympy/calculus/util.py @@ -280,8 +280,8 @@ def not_empty_in(finset_intersection, *syms): if len(syms) == 0: raise ValueError("One or more symbols must be given in syms.") - if finset_intersection.is_EmptySet: - return EmptySet() + if finset_intersection is S.EmptySet: + return S.EmptySet if isinstance(finset_intersection, Union): elm_in_sets = finset_intersection.args[0] diff --git a/sympy/core/function.py b/sympy/core/function.py index 2ddee5df54fa..7399654f14d8 100644 --- a/sympy/core/function.py +++ b/sympy/core/function.py @@ -1864,6 +1864,9 @@ def __new__(cls, variables, expr): for i in v: if not getattr(i, 'is_symbol', False): raise TypeError('variable is not a symbol: %s' % i) + if len(v) != len(set(v)): + x = [i for i in v if v.count(i) > 1][0] + raise SyntaxError("duplicate argument '%s' in Lambda args" % x) if len(v) == 1 and v[0] == expr: return S.IdentityFunction diff --git a/sympy/ntheory/continued_fraction.py b/sympy/ntheory/continued_fraction.py index 1c38d3bf2423..848f30e9c09d 100644 --- a/sympy/ntheory/continued_fraction.py +++ b/sympy/ntheory/continued_fraction.py @@ -171,8 +171,8 @@ def continued_fraction_periodic(p, q, d=0, s=1): if (d - p**2)%q: d *= q**2 sd *= q - p *= abs(q) - q *= abs(q) + p *= q + q *= q terms = [] pq = {} diff --git a/sympy/printing/pretty/pretty.py b/sympy/printing/pretty/pretty.py index e070adf3acb1..d67ff0b19982 100644 --- a/sympy/printing/pretty/pretty.py +++ b/sympy/printing/pretty/pretty.py @@ -163,6 +163,7 @@ def _print_Atom(self, e): _print_Naturals = _print_Atom _print_Naturals0 = _print_Atom _print_Integers = _print_Atom + _print_Rationals = _print_Atom _print_Complexes = _print_Atom def _print_Reals(self, e): diff --git a/sympy/printing/pretty/pretty_symbology.py b/sympy/printing/pretty/pretty_symbology.py index d27eb51653e4..348a59bcf7f3 100644 --- a/sympy/printing/pretty/pretty_symbology.py +++ b/sympy/printing/pretty/pretty_symbology.py @@ -501,6 +501,7 @@ def xsym(sym): (U('DOUBLE-STRUCK CAPITAL N') + U('SUBSCRIPT ZERO'))), 'Integers': U('DOUBLE-STRUCK CAPITAL Z'), + 'Rationals': U('DOUBLE-STRUCK CAPITAL Q'), 'Reals': U('DOUBLE-STRUCK CAPITAL R'), 'Complexes': U('DOUBLE-STRUCK CAPITAL C'), 'Union': U('UNION'), diff --git a/sympy/printing/str.py b/sympy/printing/str.py index ee560ca0a822..0ce283b18bed 100644 --- a/sympy/printing/str.py +++ b/sympy/printing/str.py @@ -582,6 +582,9 @@ def _print_Naturals(self, expr): def _print_Naturals0(self, expr): return 'Naturals0' + def _print_Rationals(self, expr): + return 'Rationals' + def _print_Reals(self, expr): return 'Reals' diff --git a/sympy/sets/__init__.py b/sympy/sets/__init__.py index 453fc449e9d2..a66ce07138aa 100644 --- a/sympy/sets/__init__.py +++ b/sympy/sets/__init__.py @@ -10,4 +10,5 @@ Naturals0 = S.Naturals0 UniversalSet = S.UniversalSet Integers = S.Integers +Rationals = S.Rationals del S diff --git a/sympy/sets/conditionset.py b/sympy/sets/conditionset.py index 3a4f3a8282ce..6437f471a84a 100644 --- a/sympy/sets/conditionset.py +++ b/sympy/sets/conditionset.py @@ -175,7 +175,15 @@ def free_symbols(self): s, c, b = self.args return (c.free_symbols - s.free_symbols) | b.free_symbols - def contains(self, other): + def _contains(self, other): + d = Dummy() + try: + return self.as_relational(d).subs(d, other) + except TypeError: + # couldn't do the substitution without error + return False + + def as_relational(self, other): return And(Lambda(self.sym, self.condition)( other), self.base_set.contains(other)) diff --git a/sympy/sets/fancysets.py b/sympy/sets/fancysets.py index 3da73cf4602f..0d4804359b10 100644 --- a/sympy/sets/fancysets.py +++ b/sympy/sets/fancysets.py @@ -4,14 +4,67 @@ from sympy.core.compatibility import as_int, with_metaclass, range, PY3 from sympy.core.expr import Expr from sympy.core.function import Lambda +from sympy.core.numbers import oo +from sympy.core.relational import Eq from sympy.core.singleton import Singleton, S from sympy.core.symbol import Dummy, symbols from sympy.core.sympify import _sympify, sympify, converter from sympy.logic.boolalg import And -from sympy.sets.sets import Set, Interval, Union, FiniteSet, ProductSet +from sympy.sets.sets import (Set, Interval, Union, FiniteSet, + ProductSet, Intersection) +from sympy.sets.contains import Contains +from sympy.sets.conditionset import ConditionSet +from sympy.utilities.iterables import flatten from sympy.utilities.misc import filldedent +class Rationals(with_metaclass(Singleton, Set)): + """ + Represents the rational numbers. This set is also available as + the Singleton, S.Rationals. + + Examples + ======== + + >>> from sympy import S + >>> S.Half in S.Rationals + True + >>> iterable = iter(S.Rationals) + >>> [next(iterable) for i in range(12)] + [0, 1, -1, 1/2, 2, -1/2, -2, 1/3, 3, -1/3, -3, 2/3] + """ + + is_iterable = True + _inf = S.NegativeInfinity + _sup = S.Infinity + + def _contains(self, other): + if not isinstance(other, Expr): + return False + if other.is_Number: + return other.is_Rational + return other.is_rational + + def __iter__(self): + from sympy.core.numbers import igcd, Rational + yield S.Zero + yield S.One + yield S.NegativeOne + d = 2 + while True: + for n in range(d): + if igcd(n, d) == 1: + yield Rational(n, d) + yield Rational(d, n) + yield Rational(-n, d) + yield Rational(-d, n) + d += 1 + + @property + def _boundary(self): + return self + + class Naturals(with_metaclass(Singleton, Set)): """ Represents the natural numbers (or counting numbers) which are all @@ -47,11 +100,11 @@ class Naturals(with_metaclass(Singleton, Set)): def _contains(self, other): if not isinstance(other, Expr): - return S.false + return False elif other.is_positive and other.is_integer: - return S.true + return True elif other.is_integer is False or other.is_positive is False: - return S.false + return False def __iter__(self): i = self._inf @@ -63,6 +116,10 @@ def __iter__(self): def _boundary(self): return self + def as_relational(self, x): + from sympy.functions.elementary.integers import floor + return And(Eq(floor(x), x), x >= self.inf, x < oo) + class Naturals0(Naturals): """Represents the whole numbers which are all the non-negative integers, @@ -121,10 +178,7 @@ class Integers(with_metaclass(Singleton, Set)): def _contains(self, other): if not isinstance(other, Expr): return S.false - elif other.is_integer: - return S.true - elif other.is_integer is False: - return S.false + return other.is_integer def __iter__(self): yield S.Zero @@ -146,6 +200,10 @@ def _sup(self): def _boundary(self): return self + def as_relational(self, x): + from sympy.functions.elementary.integers import floor + return And(Eq(floor(x), x), -oo < x, x < oo) + class Reals(with_metaclass(Singleton, Interval)): """ @@ -246,9 +304,13 @@ class ImageSet(Set): def __new__(cls, flambda, *sets): if not isinstance(flambda, Lambda): raise ValueError('first argument must be a Lambda') - if flambda is S.IdentityFunction and len(sets) == 1: + + if flambda is S.IdentityFunction: + if len(sets) != 1: + raise ValueError('identify function requires a single set') return sets[0] - if not flambda.expr.free_symbols or not flambda.expr.args: + + if not set(flambda.variables) & flambda.expr.free_symbols: return FiniteSet(flambda.expr) return Basic.__new__(cls, flambda, *sets) @@ -275,17 +337,11 @@ def _contains(self, other): from sympy.solvers.solvers import solve from sympy.utilities.iterables import is_sequence, iterable, cartes L = self.lamda - if is_sequence(other): - if not is_sequence(L.expr): - return S.false - if len(L.expr) != len(other): - raise ValueError(filldedent(''' - Dimensions of other and output of Lambda are different.''')) - elif iterable(other): - raise ValueError(filldedent(''' - `other` should be an ordered object like a Tuple.''')) + if is_sequence(other) != is_sequence(L.expr): + return False + elif is_sequence(other) and len(L.expr) != len(other): + return False - solns = None if self._is_multivariate(): if not is_sequence(L.expr): # exprs -> (numer, denom) and check again @@ -333,6 +389,12 @@ def _contains(self, other): # for x, y and getting (x, 0), (0, y), (0, 0) solns = [i for i in solns if not any( s in i for s in variables)] + if not solns: + return False + else: + # not sure if [] means no solution or + # couldn't find one + return else: x = L.variables[0] if isinstance(L.expr, Expr): @@ -344,31 +406,29 @@ def _contains(self, other): msgset = solnsSet else: # scalar -> vector + # note: it is not necessary for components of other + # to be in the corresponding base set unless the + # computed component is always in the corresponding + # domain. e.g. 1/2 is in imageset(x, x/2, Integers) + # while it cannot be in imageset(x, x + 2, Integers). + # So when the base set is comprised of integers or reals + # perhaps a pre-check could be done to see if the computed + # values are still in the set. + dom = self.base_set for e, o in zip(L.expr, other): - solns = solveset(e - o, x) - if solns is S.EmptySet: - return S.false - for soln in solns: - try: - if soln in self.base_set: - break # check next pair - except TypeError: - if self.base_set.contains(soln.evalf()): - break - else: - return S.false # never broke so there was no True - return S.true - - if solns is None: - raise NotImplementedError(filldedent(''' - Determining whether %s contains %s has not - been implemented.''' % (msgset, other))) + msgset = dom + other = e - o + dom = dom.intersection(solveset(e - o, x, domain=dom)) + if not dom: + # there is no solution in common + return False + return not isinstance(dom, Intersection) for soln in solns: try: if soln in self.base_set: - return S.true + return True except TypeError: - return self.base_set.contains(soln.evalf()) + return return S.false @property @@ -913,7 +973,6 @@ def __new__(cls, sets, polar=False): new_sets.append(sets) # Normalize input theta for k, v in enumerate(new_sets): - from sympy.sets import ProductSet new_sets[k] = ProductSet(v.args[0], normalize_theta_set(v.args[1])) sets = Union(*new_sets) diff --git a/sympy/sets/handlers/functions.py b/sympy/sets/handlers/functions.py index d811e87b6dd8..c4b6423c62cb 100644 --- a/sympy/sets/handlers/functions.py +++ b/sympy/sets/handlers/functions.py @@ -1,4 +1,4 @@ -from sympy import Set, symbols, exp, log, S, Wild +from sympy import Set, symbols, exp, log, S, Wild, Dummy, oo from sympy.core import Expr, Add from sympy.core.function import Lambda, _coeff_isneg, FunctionClass from sympy.core.mod import Mod @@ -6,7 +6,7 @@ from sympy.multipledispatch import dispatch from sympy.sets import (imageset, Interval, FiniteSet, Union, ImageSet, EmptySet, Intersection, Range) -from sympy.sets.fancysets import Integers, Naturals +from sympy.sets.fancysets import Integers, Naturals, Reals _x, _y = symbols("x y") @@ -37,6 +37,9 @@ def _set_function(f, x): if len(expr.free_symbols) > 1 or len(f.variables) != 1: return var = f.variables[0] + if not var.is_real: + if expr.subs(var, Dummy(real=True)).is_real is False: + return if expr.is_Piecewise: result = S.EmptySet @@ -56,7 +59,7 @@ def _set_function(f, x): # remove the part which has been `imaged` domain_set = Complement(domain_set, intrvl) - if domain_set.is_EmptySet: + if domain_set is S.EmptySet: break return result @@ -169,6 +172,8 @@ def _set_function(f, self): return n = f.variables[0] + if expr == abs(n): + return S.Naturals0 # f(x) + c and f(-x) + c cover the same integers # so choose the form that has the fewest negatives @@ -212,11 +217,28 @@ def _set_function(f, self): x = f.variables[0] if not expr.free_symbols - {x}: + if expr == abs(x): + if self is S.Naturals: + return self + return S.Naturals0 step = expr.coeff(x) c = expr.subs(x, 0) if c.is_Integer and step.is_Integer and expr == step*x + c: if self is S.Naturals: c += step if step > 0: - return Range(c, S.Infinity, step) - return Range(c, S.NegativeInfinity, step) + if step == 1: + if c == 0: + return S.Naturals0 + elif c == 1: + return S.Naturals + return Range(c, oo, step) + return Range(c, -oo, step) + + +@dispatch(FunctionUnion, Reals) +def _set_function(f, self): + expr = f.expr + if not isinstance(expr, Expr): + return + return _set_function(f, Interval(-oo, oo)) diff --git a/sympy/sets/handlers/intersection.py b/sympy/sets/handlers/intersection.py index 34b9a94cf6e3..ea4108fae38a 100644 --- a/sympy/sets/handlers/intersection.py +++ b/sympy/sets/handlers/intersection.py @@ -3,7 +3,7 @@ from sympy.multipledispatch import dispatch from sympy.sets.conditionset import ConditionSet from sympy.sets.fancysets import (Integers, Naturals, Reals, Range, - ImageSet, Naturals0) + ImageSet, Naturals0, Rationals) from sympy.sets.sets import UniversalSet, imageset, ProductSet @@ -25,27 +25,12 @@ def intersection_sets(a, b): @dispatch(Naturals, Naturals) def intersection_sets(a, b): - return a if a is S.Naturals0 else b - -@dispatch(Naturals, Interval) -def intersection_sets(a, b): - return Intersection(S.Integers, b, Interval(a._inf, S.Infinity)) + return a if a is S.Naturals else b @dispatch(Interval, Naturals) def intersection_sets(a, b): return intersection_sets(b, a) -@dispatch(Integers, Interval) -def intersection_sets(a, b): - try: - from sympy.functions.elementary.integers import floor, ceiling - if b._inf is S.NegativeInfinity and b._sup is S.Infinity: - return a - s = Range(ceiling(b.left), floor(b.right) + 1) - return intersection_sets(s, b) # take out endpoints if open interval - except ValueError: - return None - @dispatch(ComplexRegion, Set) def intersection_sets(self, other): if other.is_ComplexRegion: @@ -157,7 +142,7 @@ def intersection_sets(a, b): # we want to know when the two equations might # have integer solutions so we use the diophantine # solver - va, vb = diop_linear(eq(r1, Dummy()) - eq(r2, Dummy())) + va, vb = diop_linear(eq(r1, Dummy('a')) - eq(r2, Dummy('b'))) # check for no solution no_solution = va is None and vb is None @@ -446,3 +431,33 @@ def intersection_sets(a, b): @dispatch(Set, Set) def intersection_sets(a, b): return None + +@dispatch(Integers, Rationals) +def intersection_sets(a, b): + return a + +@dispatch(Naturals, Rationals) +def intersection_sets(a, b): + return a + +@dispatch(Rationals, Reals) +def intersection_sets(a, b): + return a + +def _intlike_interval(a, b): + try: + from sympy.functions.elementary.integers import floor, ceiling + if b._inf is S.NegativeInfinity and b._sup is S.Infinity: + return a + s = Range(max(a.inf, ceiling(b.left)), floor(b.right) + 1) + return intersection_sets(s, b) # take out endpoints if open interval + except ValueError: + return None + +@dispatch(Integers, Interval) +def intersection_sets(a, b): + return _intlike_interval(a, b) + +@dispatch(Naturals, Interval) +def intersection_sets(a, b): + return _intlike_interval(a, b) diff --git a/sympy/sets/sets.py b/sympy/sets/sets.py index b85427e79332..03cf57a30bd8 100644 --- a/sympy/sets/sets.py +++ b/sympy/sets/sets.py @@ -1,17 +1,18 @@ from __future__ import print_function, division from itertools import product +from collections import defaultdict import inspect from sympy.core.basic import Basic from sympy.core.compatibility import (iterable, with_metaclass, - ordered, range, PY3) + ordered, range, PY3, is_sequence) from sympy.core.cache import cacheit from sympy.core.evalf import EvalfMixin from sympy.core.evaluate import global_evaluate from sympy.core.expr import Expr from sympy.core.function import FunctionClass -from sympy.core.logic import fuzzy_bool +from sympy.core.logic import fuzzy_bool, fuzzy_or from sympy.core.mul import Mul from sympy.core.numbers import Float from sympy.core.operations import LatticeOp @@ -27,6 +28,13 @@ from mpmath import mpi, mpf + +tfn = defaultdict(lambda: None, { + True: S.true, + S.true: S.true, + False: S.false, + S.false: S.false}) + class Set(Basic): """ The base class for any kind of set. @@ -270,28 +278,57 @@ def _sup(self): def contains(self, other): """ - Returns True if 'other' is contained in 'self' as an element. - - As a shortcut it is possible to use the 'in' operator: + Returns a SymPy value indicating whether ``other`` is contained + in ``self``: ``true`` if it is, ``false`` if it isn't, else + an unevaluated ``Contains`` expression (or, as in the case of + ConditionSet and a union of FiniteSet/Intervals, an expression + indicating the conditions for containment). Examples ======== - >>> from sympy import Interval + >>> from sympy import Interval, S + >>> from sympy.abc import x + >>> Interval(0, 1).contains(0.5) True - >>> 0.5 in Interval(0, 1) - True + As a shortcut it is possible to use the 'in' operator, but that + will raise an error unless an affirmative true or false is not + obtained. + + >>> Interval(0, 1).contains(x) + (0 <= x) & (x <= 1) + >>> x in Interval(0, 1) + Traceback (most recent call last): + ... + TypeError: did not evaluate to a bool: None + + The result of 'in' is a bool, not a SymPy value + + >>> 1 in Interval(0, 2) + True + >>> _ is S.true + False """ other = sympify(other, strict=True) - ret = sympify(self._contains(other)) - if ret is None: - ret = Contains(other, self, evaluate=False) - return ret + c = self._contains(other) + if c is None: + return Contains(other, self, evaluate=False) + b = tfn[c] + if b is None: + return c + return b def _contains(self, other): - raise NotImplementedError("(%s)._contains(%s)" % (self, other)) + raise NotImplementedError(filldedent(''' + (%s)._contains(%s) is not defined. This method, when + defined, will receive a sympified object. The method + should return True, False, None or something that + expresses what must be true for the containment of that + object in self to be evaluated. If None is returned + then a generic Contains object will be returned + by the ``contains`` method.''' % (self, other))) def is_subset(self, other): """ @@ -308,10 +345,12 @@ def is_subset(self, other): """ if isinstance(other, Set): - # XXX issue 16873 - # self might be an unevaluated form of self - # so the equality test will fail - return self.intersect(other) == self + s_o = self.intersect(other) + if s_o == self: + return True + elif not isinstance(other, Intersection): + return False + return s_o else: raise ValueError("Unknown argument '%s'" % other) @@ -556,10 +595,12 @@ def __sub__(self, other): return Complement(self, other) def __contains__(self, other): - symb = sympify(self.contains(other)) - if not (symb is S.true or symb is S.false): - raise TypeError('contains did not evaluate to a bool: %r' % symb) - return bool(symb) + other = sympify(other) + c = self._contains(other) + b = tfn[c] + if b is None: + raise TypeError('did not evaluate to a bool: %r' % c) + return b class ProductSet(Set): @@ -648,13 +689,21 @@ def _contains(self, element): Passes operation on to constituent sets """ - try: + if is_sequence(element): if len(element) != len(self.args): - return false - except TypeError: # maybe element isn't an iterable - return false - return And(* - [set.contains(item) for set, item in zip(self.sets, element)]) + return False + elif len(self.args) > 1: + return False + d = [Dummy() for i in element] + reps = dict(zip(d, element)) + return tfn[self.as_relational(*d).xreplace(reps)] + + def as_relational(self, *symbols): + if len(symbols) != len(self.args) or not all( + i.is_Symbol for i in symbols): + raise ValueError( + 'number of symbols must match the number of sets') + return And(*[s.contains(i) for s, i in zip(self.args, symbols)]) @property def sets(self): @@ -915,17 +964,21 @@ def _contains(self, other): if not other.is_extended_real is None: return other.is_extended_real - if self.left_open: - expr = other > self.start - else: - expr = other >= self.start + d = Dummy() + return self.as_relational(d).subs(d, other) + def as_relational(self, x): + """Rewrite an interval in terms of inequalities and logic operators.""" + x = sympify(x) if self.right_open: - expr = And(expr, other < self.end) + right = x < self.end else: - expr = And(expr, other <= self.end) - - return _sympify(expr) + right = x <= self.end + if self.left_open: + left = self.start < x + else: + left = self.start <= x + return And(left, right) @property def _measure(self): @@ -958,19 +1011,6 @@ def is_right_unbounded(self): """Return ``True`` if the right endpoint is positive infinity. """ return self.right is S.Infinity or self.right == Float("+inf") - def as_relational(self, x): - """Rewrite an interval in terms of inequalities and logic operators.""" - x = sympify(x) - if self.right_open: - right = x < self.end - else: - right = x <= self.end - if self.left_open: - left = self.start < x - else: - left = self.start <= x - return And(left, right) - def _eval_Eq(self, other): if not isinstance(other, Interval): if isinstance(other, FiniteSet): @@ -1062,9 +1102,6 @@ def _sup(self): from sympy.functions.elementary.miscellaneous import Max return Max(*[set.sup for set in self.args]) - def _contains(self, other): - return Or(*[set.contains(other) for set in self.args]) - @property def _measure(self): # Measure of a union is the sum of the measures of the sets minus @@ -1120,14 +1157,28 @@ def boundary_of_set(i): return b return Union(*map(boundary_of_set, range(len(self.args)))) + def _contains(self, other): + try: + d = Dummy() + r = self.as_relational(d).subs(d, other) + b = tfn[r] + if b is None and not any(isinstance(i.contains(other), Contains) + for i in self.args): + return r + return b + except (TypeError, NotImplementedError): + return Or(*[s.contains(other) for s in self.args]) + def as_relational(self, symbol): """Rewrite a Union in terms of equalities and logic operators. """ - if len(self.args) == 2: - a, b = self.args - if (a.sup == b.inf and a.inf is S.NegativeInfinity - and b.sup is S.Infinity): - return And(Ne(symbol, a.sup), symbol < b.sup, symbol > a.inf) - return Or(*[set.as_relational(symbol) for set in self.args]) + if all(isinstance(i, (FiniteSet, Interval)) for i in self.args): + if len(self.args) == 2: + a, b = self.args + if (a.sup == b.inf and a.inf is S.NegativeInfinity + and b.sup is S.Infinity): + return And(Ne(symbol, a.sup), symbol < b.sup, symbol > a.inf) + return Or(*[set.as_relational(symbol) for set in self.args]) + raise NotImplementedError('relational of Union with non-Intervals') @property def is_iterable(self): @@ -1613,16 +1664,9 @@ def _contains(self, other): False """ - r = false - for e in self.args: - # override global evaluation so we can use Eq to do - # do the evaluation - t = Eq(e, other, evaluate=True) - if t is true: - return t - elif t is not false: - r = None - return r + # evaluate=True is needed to override evaluate=False context; + # we need Eq to do the evaluation + return fuzzy_or([tfn[Eq(e, other, evaluate=True)] for e in self.args]) @property def _boundary(self): @@ -1840,9 +1884,11 @@ def imageset(*args): if isinstance(set, ImageSet): if len(set.lamda.variables) == 1 and len(f.variables) == 1: - return imageset(Lambda(set.lamda.variables[0], - f.expr.subs(f.variables[0], set.lamda.expr)), - set.base_set) + x = set.lamda.variables[0] + y = f.variables[0] + return imageset( + Lambda(x, f.expr.subs(y, set.lamda.expr)), + set.base_set) if r is not None: return r @@ -1942,7 +1988,7 @@ def simplify_intersection(args): raise TypeError("Input args to Union must be Sets") # If any EmptySets return EmptySet - if any(s.is_EmptySet for s in args): + if S.EmptySet in args: return S.EmptySet # Handle Finite sets diff --git a/sympy/solvers/solveset.py b/sympy/solvers/solveset.py index c3f81669db63..9eb4ba861baf 100644 --- a/sympy/solvers/solveset.py +++ b/sympy/solvers/solveset.py @@ -2364,8 +2364,8 @@ def substitution(system, symbols, result=[{}], known_symbols=[], complements = {} intersections = {} - # when total_solveset_call is equals to total_conditionset - # means solvest fail to solve all the eq. + # when total_solveset_call equals total_conditionset + # it means that solveset failed to solve all eqs. total_conditionset = -1 total_solveset_call = -1

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index ebb6a98cf299..b4911a41de20 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -898,14 +898,21 @@ def test_sympy__sets__setexpr__SetExpr(): assert _test_args(SetExpr(Interval(0, 1))) +def test_sympy__sets__fancysets__Rationals(): + from sympy.sets.fancysets import Rationals + assert _test_args(Rationals()) + + def test_sympy__sets__fancysets__Naturals(): from sympy.sets.fancysets import Naturals assert _test_args(Naturals()) + def test_sympy__sets__fancysets__Naturals0(): from sympy.sets.fancysets import Naturals0 assert _test_args(Naturals0()) + def test_sympy__sets__fancysets__Integers(): from sympy.sets.fancysets import Integers assert _test_args(Integers()) diff --git a/sympy/core/tests/test_function.py b/sympy/core/tests/test_function.py index ff2d4a6ed265..a7bf674bb853 100644 --- a/sympy/core/tests/test_function.py +++ b/sympy/core/tests/test_function.py @@ -207,6 +207,9 @@ def test_Lambda(): raises(TypeError, lambda: Lambda(1, x)) assert Lambda(x, 1)(1) is S.One + raises(SyntaxError, lambda: Lambda((x, x), x + 2)) + + def test_IdentityFunction(): assert Lambda(x, x) is Lambda(y, y) is S.IdentityFunction diff --git a/sympy/sets/tests/test_conditionset.py b/sympy/sets/tests/test_conditionset.py index b976c2c91953..16e34c9de124 100644 --- a/sympy/sets/tests/test_conditionset.py +++ b/sympy/sets/tests/test_conditionset.py @@ -167,4 +167,5 @@ def test_contains(): assert ConditionSet(x, y > 5, Interval(1, 7) ).contains(8) is S.false assert ConditionSet(x, y > 5, Interval(1, 7) - ).contains(w) == And(w >= 1, w <= 7, y > 5) + ).contains(w) == And(S(1) <= w, w <= 7, y > 5) + assert 0 not in ConditionSet(x, 1/x >= 0, S.Reals) diff --git a/sympy/sets/tests/test_contains.py b/sympy/sets/tests/test_contains.py index 4efd8aee97fd..5e8d87d175e7 100644 --- a/sympy/sets/tests/test_contains.py +++ b/sympy/sets/tests/test_contains.py @@ -1,4 +1,5 @@ from sympy import Symbol, Contains, S, Interval, FiniteSet, oo, Eq +from sympy.core.expr import unchanged from sympy.utilities.pytest import raises def test_contains_basic(): @@ -12,8 +13,8 @@ def test_contains_basic(): def test_issue_6194(): x = Symbol('x') - assert Contains(x, Interval(0, 1)) != (x >= 0) & (x <= 1) - assert Interval(0, 1).contains(x) == (x >= 0) & (x <= 1) + assert unchanged(Contains, x, Interval(0, 1)) + assert Interval(0, 1).contains(x) == (S(0) <= x) & (x <= 1) assert Contains(x, FiniteSet(0)) != S.false assert Contains(x, Interval(1, 1)) != S.false assert Contains(x, S.Integers) != S.false diff --git a/sympy/sets/tests/test_fancysets.py b/sympy/sets/tests/test_fancysets.py index 2764c1b7c8fc..87748fb5e8c3 100644 --- a/sympy/sets/tests/test_fancysets.py +++ b/sympy/sets/tests/test_fancysets.py @@ -1,5 +1,4 @@ from sympy.core.compatibility import range, PY3 -from sympy.core.mod import Mod from sympy.sets.fancysets import (ImageSet, Range, normalize_theta_set, ComplexRegion) from sympy.sets.sets import (FiniteSet, Interval, imageset, Union, @@ -32,6 +31,10 @@ def test_naturals(): assert N.inf == 1 assert N.sup == oo + assert not N.contains(oo) + for s in (S.Naturals0, S.Naturals): + assert s.intersection(S.Reals) is s + assert s.is_subset(S.Reals) def test_naturals0(): @@ -39,6 +42,7 @@ def test_naturals0(): assert 0 in N assert -1 not in N assert next(iter(N)) == 0 + assert not N.contains(oo) def test_integers(): @@ -46,6 +50,9 @@ def test_integers(): assert 5 in Z assert -5 in Z assert 5.5 not in Z + assert not Z.contains(oo) + assert not Z.contains(-oo) + zi = iter(Z) a, b, c, d = next(zi), next(zi), next(zi), next(zi) assert (a, b, c, d) == (0, 1, -1, 2) @@ -64,7 +71,8 @@ def test_integers(): def test_ImageSet(): assert ImageSet(Lambda(x, 1), S.Integers) == FiniteSet(1) - assert ImageSet(Lambda(x, y), S.Integers) == FiniteSet(y) + assert ImageSet(Lambda(x, y), S.Integers + ) == {y} squares = ImageSet(Lambda(x, x**2), S.Naturals) assert 4 in squares assert 5 not in squares @@ -385,6 +393,7 @@ def test_Reals(): assert sqrt(-1) not in S.Reals assert S.Reals == Interval(-oo, oo) assert S.Reals != Interval(0, oo) + assert S.Reals.is_subset(Interval(-oo, oo)) def test_Complex(): @@ -802,3 +811,31 @@ def test_issue_16871b(): def test_no_mod_on_imaginary(): assert imageset(Lambda(x, 2*x + 3*I), S.Integers ) == ImageSet(Lambda(x, 2*x + I), S.Integers) + + +def test_Rationals(): + assert S.Integers.is_subset(S.Rationals) + assert S.Naturals.is_subset(S.Rationals) + assert S.Naturals0.is_subset(S.Rationals) + assert S.Rationals.is_subset(S.Reals) + assert S.Rationals.inf == -oo + assert S.Rationals.sup == oo + it = iter(S.Rationals) + assert [next(it) for i in range(12)] == [ + 0, 1, -1, S(1)/2, 2, -S(1)/2, -2, + S(1)/3, 3, -S(1)/3, -3, S(2)/3] + assert Basic() not in S.Rationals + assert S.Half in S.Rationals + assert 1.0 not in S.Rationals + assert 2 in S.Rationals + r = symbols('r', rational=True) + assert r in S.Rationals + raises(TypeError, lambda: x in S.Rationals) + + +def test_imageset_intersection(): + n = Dummy() + s = ImageSet(Lambda(n, -I*(I*(2*pi*n - pi/4) + + log(Abs(sqrt(-I))))), S.Integers) + assert s.intersect(S.Reals) == ImageSet( + Lambda(n, 2*pi*n + 7*pi/4), S.Integers) diff --git a/sympy/sets/tests/test_sets.py b/sympy/sets/tests/test_sets.py index c839ceb4ed4d..67761ce0045c 100644 --- a/sympy/sets/tests/test_sets.py +++ b/sympy/sets/tests/test_sets.py @@ -3,7 +3,7 @@ FiniteSet, Intersection, imageset, I, true, false, ProductSet, E, sqrt, Complement, EmptySet, sin, cos, Lambda, ImageSet, pi, Eq, Pow, Contains, Sum, rootof, SymmetricDifference, Piecewise, - Matrix, signsimp, Range, Add, symbols) + Matrix, signsimp, Range, Add, symbols, zoo) from mpmath import mpi from sympy.core.compatibility import range @@ -14,9 +14,22 @@ def test_imageset(): ints = S.Integers + assert imageset(x, x - 1, S.Naturals) is S.Naturals0 + assert imageset(x, x + 1, S.Naturals0) is S.Naturals + assert imageset(x, abs(x), S.Naturals0) is S.Naturals0 + assert imageset(x, abs(x), S.Naturals) is S.Naturals + assert imageset(x, abs(x), S.Integers) is S.Naturals0 + # issue 16878a + r = symbols('r', real=True) + assert (1, r) not in imageset(x, (x, x), S.Reals) + assert (r, r) in imageset(x, (x, x), S.Reals) + assert 1 + I in imageset(x, x + I, S.Reals) + assert {1} not in imageset(x, (x,), S.Reals) + assert (1, 1) not in imageset(x, (x,) , S.Reals) raises(TypeError, lambda: imageset(x, ints)) raises(ValueError, lambda: imageset(x, y, z, ints)) raises(ValueError, lambda: imageset(Lambda(x, cos(x)), y)) + raises(ValueError, lambda: imageset(Lambda(x, x), ints, ints)) assert imageset(cos, ints) == ImageSet(Lambda(x, cos(x)), ints) def f(x): return cos(x) @@ -24,7 +37,8 @@ def f(x): f = lambda x: cos(x) assert imageset(f, ints) == ImageSet(Lambda(x, cos(x)), ints) assert imageset(x, 1, ints) == FiniteSet(1) - assert imageset(x, y, ints) == FiniteSet(y) + assert imageset(x, y, ints) == {y} + assert imageset((x, y), (1, z), ints*S.Reals) == {(1, z)} clash = Symbol('x', integer=true) assert (str(imageset(lambda x: x + clash, Interval(-2, 1)).lamda.expr) in ('_x + x', 'x + _x')) @@ -250,8 +264,8 @@ def test_intersect1(): assert all(i.intersection(S.Integers) is i for i in (S.Naturals, S.Naturals0)) s = S.Naturals0 - assert S.Naturals.intersection(s) is s - assert s.intersection(S.Naturals) is s + assert S.Naturals.intersection(s) is S.Naturals + assert s.intersection(S.Naturals) is S.Naturals x = Symbol('x') assert Interval(0, 2).intersect(Interval(1, 2)) == Interval(1, 2) assert Interval(0, 2).intersect(Interval(1, 2, True)) == \ @@ -508,9 +522,9 @@ def test_contains(): # non-bool results assert Union(Interval(1, 2), Interval(3, 4)).contains(x) == \ - Or(And(x <= 2, x >= 1), And(x <= 4, x >= 3)) + Or(And(S(1) <= x, x <= 2), And(S(3) <= x, x <= 4)) assert Intersection(Interval(1, x), Interval(2, 3)).contains(y) == \ - And(y <= 3, y <= x, y >= 1, y >= 2) + And(y <= 3, y <= x, S(1) <= y, S(2) <= y) assert (S.Complexes).contains(S.ComplexInfinity) == S.false @@ -518,10 +532,10 @@ def test_contains(): def test_interval_symbolic(): x = Symbol('x') e = Interval(0, 1) - assert e.contains(x) == And(0 <= x, x <= 1) + assert e.contains(x) == And(S(0) <= x, x <= 1) raises(TypeError, lambda: x in e) e = Interval(0, 1, True, True) - assert e.contains(x) == And(0 < x, x < 1) + assert e.contains(x) == And(S(0) < x, x < 1) def test_union_contains(): @@ -529,9 +543,10 @@ def test_union_contains(): i1 = Interval(0, 1) i2 = Interval(2, 3) i3 = Union(i1, i2) + assert i3.as_relational(x) == Or(And(S(0) <= x, x <= 1), And(S(2) <= x, x <= 3)) raises(TypeError, lambda: x in i3) e = i3.contains(x) - assert e == Or(And(0 <= x, x <= 1), And(2 <= x, x <= 3)) + assert e == i3.as_relational(x) assert e.subs(x, -0.5) is false assert e.subs(x, 0.5) is true assert e.subs(x, 1.5) is false @@ -1000,7 +1015,7 @@ def test_issue_10113(): def test_issue_10248(): assert list(Intersection(S.Reals, FiniteSet(x))) == [ - And(x < oo, x > -oo)] + (-oo < x) & (x < oo)] def test_issue_9447(): @@ -1114,3 +1129,16 @@ def test_union_intersection_constructor(): assert Union({1}, {2}) == FiniteSet(1, 2) assert Intersection({1, 2}, {2, 3}) == FiniteSet(2) + + +def test_Union_contains(): + assert zoo not in Union( + Interval.open(-oo, 0), Interval.open(0, oo)) + + +@XFAIL +def test_issue_16878b(): + # in intersection_sets for (ImageSet, Set) there is no code + # that handles the base_set of S.Reals like there is + # for Integers + assert imageset(x, (x, x), S.Reals).is_subset(S.Reals**2) is True diff --git a/sympy/vector/tests/test_coordsysrect.py b/sympy/vector/tests/test_coordsysrect.py index 5f749c10e002..3f601a0f4c00 100644 --- a/sympy/vector/tests/test_coordsysrect.py +++ b/sympy/vector/tests/test_coordsysrect.py @@ -436,7 +436,7 @@ def test_check_orthogonality(): a = CoordSys3D('a', transformation=((u, v, z), (cosh(u) * cos(v), sinh(u) * sin(v), z))) assert a._check_orthogonality(a._transformation) is True - raises(ValueError, lambda: CoordSys3D('a', transformation=((x, x, z), (x, y, z)))) + raises(ValueError, lambda: CoordSys3D('a', transformation=((x, y, z), (x, x, z)))) raises(ValueError, lambda: CoordSys3D('a', transformation=( (x, y, z), (x*sin(y/2)*cos(z), x*sin(y)*sin(z), x*cos(y)))))

[ { "components": [ { "doc": "", "lines": [ 585, 586 ], "name": "StrPrinter._print_Rationals", "signature": "def _print_Rationals(self, expr):", "type": "function" } ], "file": "sympy/printing/str.py" }, { "components"...

[ "test_sympy__sets__fancysets__Rationals", "test_Lambda", "test_issue_6194", "test_naturals", "test_Rationals", "test_imageset", "test_intersect1", "test_contains", "test_interval_symbolic", "test_union_contains", "test_issue_10248" ]

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Rationals added to fancysets  #### References to other Issues or PRs  closes #9609 with added tests closes #10757 by adding Rationals closes #11863 closes #16268 by defining interaction for Naturals and Reals closes #16938 closes #16940 #### Brief description of what is fixed or changed #### Other comments #### Release Notes   - sets - Rationals added to fancysets - interactions between Z, N, N0 and R is improved  ---------- Rationals here doesn't print nicely: ``` In [1]: S.Rationals Out[1]: Rationals In [2]: S.Reals Out[2]: ℝ In [3]: S.Integers Out[3]: ℤ ``` What is `Rationals.__iter__` useful for? It currently only gives rational numbers between +-1. There is a way to enumerate all rationals in the diagram here though: https://en.wikipedia.org/wiki/Rational_number#Properties This result is driving me crazy...I will have to step through and see why `S.Naturals.intersect(S.Reals) -> Range(1, oo, 1)` but `S.Naturals0` gives itself. ```console def e2d(s): if type(s) is str: s = s.replace('==', '=') return [tuple(map(lambda i:i.strip(), li.split('='))) for li in s.strip().splitlines()] elif isinstance(s, Eq): return s.args elif type(s) is list: return list(map(e2d, s)) e2d('v_f=x\nsigma_f=f\nsigma_c=c\nsigma_p=p') s2d = lambda s: [tuple(map(lambda i:i.strip(), li.split('='))) for li in s.strip().splitlines()] ``` </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/printing/str.py] (definition of StrPrinter._print_Rationals:) def _print_Rationals(self, expr): [end of new definitions in sympy/printing/str.py] [start of new definitions in sympy/sets/conditionset.py] (definition of ConditionSet._contains:) def _contains(self, other): (definition of ConditionSet.as_relational:) def as_relational(self, other): [end of new definitions in sympy/sets/conditionset.py] [start of new definitions in sympy/sets/fancysets.py] (definition of Rationals:) class Rationals(with_metaclass(Singleton, Set)): """Represents the rational numbers. This set is also available as the Singleton, S.Rationals. Examples ======== >>> from sympy import S >>> S.Half in S.Rationals True >>> iterable = iter(S.Rationals) >>> [next(iterable) for i in range(12)] [0, 1, -1, 1/2, 2, -1/2, -2, 1/3, 3, -1/3, -3, 2/3]""" (definition of Rationals._contains:) def _contains(self, other): (definition of Rationals.__iter__:) def __iter__(self): (definition of Rationals._boundary:) def _boundary(self): (definition of Naturals.as_relational:) def as_relational(self, x): (definition of Integers.as_relational:) def as_relational(self, x): [end of new definitions in sympy/sets/fancysets.py] [start of new definitions in sympy/sets/handlers/intersection.py] (definition of _intlike_interval:) def _intlike_interval(a, b): [end of new definitions in sympy/sets/handlers/intersection.py] [start of new definitions in sympy/sets/sets.py] (definition of ProductSet.as_relational:) def as_relational(self, *symbols): [end of new definitions in sympy/sets/sets.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Range._intersect fails when (in a line) the solution is returned in other order Hi all!, well trying to fix some issue i found this, basically, the problem start in this line: fancysets.py:684 ``` a, b = diop_linear(eq(r1, Dummy()) - eq(r2, Dummy())) ``` The return is correct, but the problem is the algorithm applied next with a and b, it only check a, so the problem start when the first the Dummy is sorted after the second Dummy (are sorted by name), so when this happen the return is reversed, not a very big change, b is a, and a is b, is logic because is the same but in other order, well the problem is when is treaty in this case, and basically all intersections when this happen return ```EmptySet()```. To fix this please avoid assign names to Dummy, i think the idea is fix the algorithm to can work with both solutions, a and b to avoid problems in the future. Thx. Cya. ---------- -------------------- </issues>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-16845

16,845

sympy/sympy

1.5

6ffc2f04ad820e3f592b2107e66a16fd4585ac02

2019-05-16T22:52:03Z

diff --git a/sympy/tensor/array/__init__.py b/sympy/tensor/array/__init__.py index fac9822cd8c7..ecad09e7545d 100644 --- a/sympy/tensor/array/__init__.py +++ b/sympy/tensor/array/__init__.py @@ -204,5 +204,6 @@ from .sparse_ndim_array import MutableSparseNDimArray, ImmutableSparseNDimArray, SparseNDimArray from .ndim_array import NDimArray from .arrayop import tensorproduct, tensorcontraction, derive_by_array, permutedims +from .array_comprehension import ArrayComprehension Array = ImmutableDenseNDimArray diff --git a/sympy/tensor/array/array_comprehension.py b/sympy/tensor/array/array_comprehension.py new file mode 100644 index 000000000000..ecd452fefbef --- /dev/null +++ b/sympy/tensor/array/array_comprehension.py @@ -0,0 +1,266 @@ +from __future__ import print_function, division +import functools +from sympy.core.sympify import sympify +from sympy.core.expr import Expr +from sympy.core import Basic +from sympy.core.compatibility import Iterable +from sympy.tensor.array import MutableDenseNDimArray, ImmutableDenseNDimArray +from sympy import Symbol +from sympy.core.sympify import sympify +from sympy.core.numbers import Integer + + +class ArrayComprehension(Basic): + """ + Generate a list comprehension + If there is a symbolic dimension, for example, say [i for i in range(1, N)] where + N is a Symbol, then the expression will not be expanded to an array. Otherwise, + calling the doit() function will launch the expansion. + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) + >>> a + ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) + >>> a.doit() + [[11, 12, 13], [21, 22, 23], [31, 32, 33], [41, 42, 43]] + >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k)) + >>> b.doit() + ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k)) + + """ + def __new__(cls, function, *symbols, **assumptions): + if any(len(l) != 3 or None for l in symbols): + raise ValueError('ArrayComprehension requires values lower and upper bound' + ' for the expression') + arglist = [sympify(function)] + arglist.extend(cls._check_limits_validity(function, symbols)) + obj = Basic.__new__(cls, *arglist, **assumptions) + obj._function = obj._args[0] + obj._limits = obj._args[1:] + obj._shape = cls._calculate_shape_from_limits(obj._limits) + obj._rank = len(obj._shape) + obj._loop_size = cls._calculate_loop_size(obj._shape) + return obj + + @property + def function(self): + """ + Return the function applied across limits + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) + >>> a.function + 10*i + j + """ + return self._function + + @property + def limits(self): + """ + Return a list of the limits that will be applied while expanding the array. Each + bound contrains firstly the an variable (not necessarily to be component of the + expression, e.g. an array of constant). Then the lower bound and the upper bound + define the length of this expansion. + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) + >>> a.limits + ((i, 1, 4), (j, 1, 3)) + """ + return self._limits + + @property + def free_symbols(self): + """ + Return a set of the free_symbols in the array. Variables appeared in the bounds + are supposed to be excluded from the free symbol set. + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) + >>> a.free_symbols + set() + >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k+3)) + >>> b.free_symbols + {k} + """ + expr_free_sym = self._function.free_symbols + for var, inf, sup in self._limits: + expr_free_sym.discard(var) + if len(inf.free_symbols) > 0: + expr_free_sym = expr_free_sym.union(inf.free_symbols) + if len(sup.free_symbols) > 0: + expr_free_sym = expr_free_sym.union(sup.free_symbols) + return expr_free_sym + + @property + def variables(self): + """ + Return a list of the variables in the limits + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) + >>> a.variables + [i, j] + """ + return [l[0] for l in self._limits] + + @property + def bound_symbols(self): + """ + Return only variables that are dummy variables. Note that all variables are + dummy variables since a limit without lower bound or upper bound is not accpted. + """ + return [l[0] for l in self._limits if len(l) != 1] + + @property + def shape(self): + """ + Return the shape of the expanded array, which can have symbols. Note that both + the lower and the upper bounds are included while calculating the shape. + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) + >>> a.shape + (4, 3) + >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k+3)) + >>> b.shape + (4, k + 3) + """ + return self._shape + + @property + def is_numeric(self): + """ + Return True if the expanded array is numeric, which means that there is not + symbolic dimension. + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) + >>> a.is_numeric + True + >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k+3)) + >>> b.is_numeric + False + + """ + for var, inf, sup in self._limits: + if Basic(inf, sup).atoms(Symbol): + return False + return True + + def rank(self): + """ + Return the rank of the expanded array. + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) + >>> a.rank() + 2 + """ + return self._rank + + def __len__(self): + """ + Overload common function len().Returns the number of element in the expanded + array. Note that symbolic length is not supported and will raise an error. + + Examples + ======== + + >>> from sympy.tensor.array import ArrayComprehension + >>> from sympy.abc import i, j, k + >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) + >>> len(a) + 12 + """ + if len(self._loop_size.free_symbols) != 0: + raise ValueError('Symbolic length is not supported') + return self._loop_size + + @classmethod + def _check_limits_validity(cls, function, limits): + limits = sympify(limits) + for var, inf, sup in limits: + if any(not isinstance(i, Expr) for i in [inf, sup]): + raise TypeError('Bounds should be an Expression(combination of Integer and Symbol)') + if (inf > sup) == True: + raise ValueError('Lower bound should be inferior to upper bound') + if var in inf.free_symbols or var in sup.free_symbols: + raise ValueError('Variable should not be part of its bounds') + return limits + + @classmethod + def _calculate_shape_from_limits(cls, limits): + shape = [] + for var, inf, sup in limits: + shape.append(sup - inf + 1) + return tuple(shape) + + @classmethod + def _calculate_loop_size(cls, shape): + if len(shape) == 0: + return 0 + loop_size = 1 + for l in shape: + loop_size = loop_size * l + + return loop_size + + def doit(self): + if not self.is_numeric: + return self + + arr = self._expand_array() + return arr + + def _expand_array(self): + # To perform a subs at every element of the array. + def _array_subs(arr, var, val): + arr = MutableDenseNDimArray(arr) + for i in range(len(arr)): + index = arr._get_tuple_index(i) + arr[index] = arr[index].subs(var, val) + return arr.tolist() + + list_gen = self._function + for var, inf, sup in reversed(self._limits): + list_expr = list_gen + list_gen = [] + for val in range(inf, sup+1): + if not isinstance(list_expr, Iterable): + list_gen.append(list_expr.subs(var, val)) + else: + list_gen.append(_array_subs(list_expr, var, val)) + return ImmutableDenseNDimArray(list_gen)

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 098a0a559ca2..f7ae7575bfd5 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -3843,6 +3843,12 @@ def test_sympy__tensor__array__sparse_ndim_array__ImmutableSparseNDimArray(): assert _test_args(sparr) +def test_sympy__tensor__array__array_comprehension__ArrayComprehension(): + from sympy.tensor.array.array_comprehension import ArrayComprehension + arrcom = ArrayComprehension(x, (x, 1, 5)) + assert _test_args(arrcom) + + def test_sympy__tensor__functions__TensorProduct(): from sympy.tensor.functions import TensorProduct tp = TensorProduct(3, 4, evaluate=False) diff --git a/sympy/tensor/array/tests/test_array_comprehension.py b/sympy/tensor/array/tests/test_array_comprehension.py new file mode 100644 index 000000000000..dfd35877417c --- /dev/null +++ b/sympy/tensor/array/tests/test_array_comprehension.py @@ -0,0 +1,41 @@ +from sympy.tensor.array.array_comprehension import ArrayComprehension +from sympy.tensor.array import ImmutableDenseNDimArray +from sympy.abc import i, j, k, l, n +from sympy.utilities.pytest import raises + + +def test_array_comprehension(): + a = ArrayComprehension(i*j, (i, 1, 3), (j, 2, 4)) + b = ArrayComprehension(i, (i, 1, j+1)) + c = ArrayComprehension(i+j+k+l, (i, 1, 2), (j, 1, 3), (k, 1, 4), (l, 1, 5)) + d = ArrayComprehension(k, (i, 1, 5)) + e = ArrayComprehension(i, (j, k+1, k+5)) + assert a.doit().tolist() == [[2, 3, 4], [4, 6, 8], [6, 9, 12]] + assert a.shape == (3, 3) + assert a.is_numeric == True + assert len(a) == 9 + assert isinstance(b.doit(), ArrayComprehension) + assert isinstance(a.doit(), ImmutableDenseNDimArray) + assert b.subs(j, 3) == ArrayComprehension(i, (i, 1, 4)) + assert b.free_symbols == {j} + assert b.shape == (j + 1,) + assert b.rank() == 1 + assert b.is_numeric == False + assert c.free_symbols == set() + assert c.function == i + j + k + l + assert c.limits == ((i, 1, 2), (j, 1, 3), (k, 1, 4), (l, 1, 5)) + assert c.doit().tolist() == [[[[4, 5, 6, 7, 8], [5, 6, 7, 8, 9], [6, 7, 8, 9, 10], [7, 8, 9, 10, 11]], + [[5, 6, 7, 8, 9], [6, 7, 8, 9, 10], [7, 8, 9, 10, 11], [8, 9, 10, 11, 12]], + [[6, 7, 8, 9, 10], [7, 8, 9, 10, 11], [8, 9, 10, 11, 12], [9, 10, 11, 12, 13]]], + [[[5, 6, 7, 8, 9], [6, 7, 8, 9, 10], [7, 8, 9, 10, 11], [8, 9, 10, 11, 12]], + [[6, 7, 8, 9, 10], [7, 8, 9, 10, 11], [8, 9, 10, 11, 12], [9, 10, 11, 12, 13]], + [[7, 8, 9, 10, 11], [8, 9, 10, 11, 12], [9, 10, 11, 12, 13], [10, 11, 12, 13, 14]]]] + assert c.free_symbols == set() + assert c.variables == [i, j, k, l] + assert c.bound_symbols == [i, j, k, l] + assert d.doit().tolist() == [k, k, k, k, k] + assert len(e) == 5 + raises(TypeError, lambda: ArrayComprehension(i*j, (i, 1, 3), (j, 2, [1, 3, 2]))) + raises(ValueError, lambda: ArrayComprehension(i*j, (i, 1, 3), (j, 2, 1))) + raises(ValueError, lambda: ArrayComprehension(i*j, (i, 1, 3), (j, 2, j+1))) + raises(ValueError, lambda: len(ArrayComprehension(i*j, (i, 1, 3), (j, 2, j+4))))

[ { "components": [ { "doc": "Generate a list comprehension\nIf there is a symbolic dimension, for example, say [i for i in range(1, N)] where\nN is a Symbol, then the expression will not be expanded to an array. Otherwise,\ncalling the doit() function will launch the expansion.\n\nExamples\n=======...

[ "test_sympy__tensor__array__array_comprehension__ArrayComprehension" ]

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [Don't merge][GSoC]Added ArrayComprehension class  #### References to other Issues or PRs  #### Brief description of what is fixed or changed Added ArrayComprehension class to generate a list comprehension which can accept symbols #### Other comments The implementation is not yet finished. PR related to GSoC 2019 #### Release Notes   * tensor * Added a new array object ArrayComprehension for list comprehension.  TODO list: - [x] add unit tests - [x] add doctests in the documentation string. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/tensor/array/array_comprehension.py] (definition of ArrayComprehension:) class ArrayComprehension(Basic): """Generate a list comprehension If there is a symbolic dimension, for example, say [i for i in range(1, N)] where N is a Symbol, then the expression will not be expanded to an array. Otherwise, calling the doit() function will launch the expansion. Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) >>> a ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) >>> a.doit() [[11, 12, 13], [21, 22, 23], [31, 32, 33], [41, 42, 43]] >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k)) >>> b.doit() ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k))""" (definition of ArrayComprehension.__new__:) def __new__(cls, function, *symbols, **assumptions): (definition of ArrayComprehension.function:) def function(self): """Return the function applied across limits Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) >>> a.function 10*i + j""" (definition of ArrayComprehension.limits:) def limits(self): """Return a list of the limits that will be applied while expanding the array. Each bound contrains firstly the an variable (not necessarily to be component of the expression, e.g. an array of constant). Then the lower bound and the upper bound define the length of this expansion. Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) >>> a.limits ((i, 1, 4), (j, 1, 3))""" (definition of ArrayComprehension.free_symbols:) def free_symbols(self): """Return a set of the free_symbols in the array. Variables appeared in the bounds are supposed to be excluded from the free symbol set. Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) >>> a.free_symbols set() >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k+3)) >>> b.free_symbols {k}""" (definition of ArrayComprehension.variables:) def variables(self): """Return a list of the variables in the limits Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) >>> a.variables [i, j]""" (definition of ArrayComprehension.bound_symbols:) def bound_symbols(self): """Return only variables that are dummy variables. Note that all variables are dummy variables since a limit without lower bound or upper bound is not accpted.""" (definition of ArrayComprehension.shape:) def shape(self): """Return the shape of the expanded array, which can have symbols. Note that both the lower and the upper bounds are included while calculating the shape. Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) >>> a.shape (4, 3) >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k+3)) >>> b.shape (4, k + 3)""" (definition of ArrayComprehension.is_numeric:) def is_numeric(self): """Return True if the expanded array is numeric, which means that there is not symbolic dimension. Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) >>> a.is_numeric True >>> b = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, k+3)) >>> b.is_numeric False""" (definition of ArrayComprehension.rank:) def rank(self): """Return the rank of the expanded array. Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) >>> a.rank() 2""" (definition of ArrayComprehension.__len__:) def __len__(self): """Overload common function len().Returns the number of element in the expanded array. Note that symbolic length is not supported and will raise an error. Examples ======== >>> from sympy.tensor.array import ArrayComprehension >>> from sympy.abc import i, j, k >>> a = ArrayComprehension(10*i + j, (i, 1, 4), (j, 1, 3)) >>> len(a) 12""" (definition of ArrayComprehension._check_limits_validity:) def _check_limits_validity(cls, function, limits): (definition of ArrayComprehension._calculate_shape_from_limits:) def _calculate_shape_from_limits(cls, limits): (definition of ArrayComprehension._calculate_loop_size:) def _calculate_loop_size(cls, shape): (definition of ArrayComprehension.doit:) def doit(self): (definition of ArrayComprehension._expand_array:) def _expand_array(self): (definition of ArrayComprehension._expand_array._array_subs:) def _array_subs(arr, var, val): [end of new definitions in sympy/tensor/array/array_comprehension.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-16843

16,843

sympy/sympy

1.5

d2308e8eb55ed6acb24bcd8dbb8c410c9e5e9d5c

2019-05-16T13:22:59Z

diff --git a/sympy/functions/__init__.py b/sympy/functions/__init__.py index bcacdc3c08f6..83049f5e0b37 100644 --- a/sympy/functions/__init__.py +++ b/sympy/functions/__init__.py @@ -26,7 +26,7 @@ erfinv, erfcinv, erf2inv, Ei, expint, E1, li, Li, Si, Ci, Shi, Chi, fresnels, fresnelc) from sympy.functions.special.gamma_functions import (gamma, lowergamma, - uppergamma, polygamma, loggamma, digamma, trigamma) + uppergamma, polygamma, loggamma, digamma, trigamma, multigamma) from sympy.functions.special.zeta_functions import (dirichlet_eta, zeta, lerchphi, polylog, stieltjes) from sympy.functions.special.tensor_functions import (Eijk, LeviCivita, diff --git a/sympy/functions/special/gamma_functions.py b/sympy/functions/special/gamma_functions.py index c4cdd69841ab..ee79a3597770 100644 --- a/sympy/functions/special/gamma_functions.py +++ b/sympy/functions/special/gamma_functions.py @@ -1,12 +1,13 @@ from __future__ import print_function, division -from sympy.core import Add, S, sympify, oo, pi, Dummy, expand_func +from sympy.core import Add, S, sympify, oo, pi, Symbol, Dummy, expand_func from sympy.core.compatibility import range, as_int from sympy.core.function import Function, ArgumentIndexError from sympy.core.numbers import Rational from sympy.core.power import Pow -from .zeta_functions import zeta -from .error_functions import erf, erfc +from sympy.core.logic import fuzzy_and, fuzzy_not +from sympy.functions.special.zeta_functions import zeta +from sympy.functions.special.error_functions import erf, erfc from sympy.functions.elementary.exponential import exp, log from sympy.functions.elementary.integers import ceiling, floor from sympy.functions.elementary.miscellaneous import sqrt @@ -165,6 +166,10 @@ def _eval_conjugate(self): def _eval_is_real(self): x = self.args[0] + if x.is_nonpositive and x.is_integer: + return False + if intlike(x) and x <= 0: + return False if x.is_positive or x.is_noninteger: return True @@ -640,7 +645,7 @@ def _eval_aseries(self, n, args0, x, logx): @classmethod def eval(cls, n, z): - n, z = list(map(sympify, (n, z))) + n, z = map(sympify, (n, z)) from sympy import unpolarify if n.is_integer: @@ -1015,3 +1020,97 @@ def trigamma(x): .. [3] http://functions.wolfram.com/GammaBetaErf/PolyGamma2/ """ return polygamma(1, x) + +############################################################################### +##################### COMPLETE MULTIVARIATE GAMMA FUNCTION #################### +############################################################################### + + +class multigamma(Function): + r""" + The multivariate gamma function is a generalization of the gamma function i.e, + + .. math:: + \Gamma_p(z) = \pi^{p(p-1)/4}\prod_{k=1}^p \Gamma[z + (1 - k)/2]. + + Special case, multigamma(x, 1) = gamma(x) + + Parameters + ========== + + p: order or dimension of the multivariate gamma function + + Examples + ======== + + >>> from sympy import S, I, pi, oo, gamma, multigamma + >>> from sympy import Symbol + >>> x = Symbol('x') + >>> p = Symbol('p', positive=True, integer=True) + + >>> multigamma(x, p) + pi**(p*(p - 1)/4)*Product(gamma(-_k/2 + x + 1/2), (_k, 1, p)) + + Several special values are known: + >>> multigamma(1, 1) + 1 + >>> multigamma(4, 1) + 6 + >>> multigamma(S(3)/2, 1) + sqrt(pi)/2 + + Writing multigamma in terms of gamma function + >>> multigamma(x, 1) + gamma(x) + + >>> multigamma(x, 2) + sqrt(pi)*gamma(x)*gamma(x - 1/2) + + >>> multigamma(x, 3) + pi**(3/2)*gamma(x)*gamma(x - 1)*gamma(x - 1/2) + + See Also + ======== + + gamma, lowergamma, uppergamma, polygamma, loggamma, digamma, trigamma + sympy.functions.special.beta_functions.beta + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Multivariate_gamma_function + """ + unbranched = True + + def fdiff(self, argindex=2): + from sympy import Sum + if argindex == 2: + x, p = self.args + k = Dummy("k") + return self.func(x, p)*Sum(polygamma(0, x + (1 - k)/2), (k, 1, p)) + else: + raise ArgumentIndexError(self, argindex) + + @classmethod + def eval(cls, x, p): + from sympy import Product + x, p = map(sympify, (x, p)) + if p.is_positive is False or p.is_integer is False: + raise ValueError('Order parameter p must be positive integer.') + k = Dummy("k") + return (pi**(p*(p - 1)/4)*Product(gamma(x + (1 - k)/2), + (k, 1, p))).doit() + + def _eval_conjugate(self): + x, p = self.args + return self.func(x.conjugate(), p) + + def _eval_is_real(self): + x, p = self.args + y = 2*x + if y.is_integer and (y <= (p - 1)) is True: + return False + if intlike(y) and (y <= (p - 1)): + return False + if y > (p - 1) or y.is_noninteger: + return True

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 1a03df681874..37756114b63b 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -2218,6 +2218,10 @@ def test_sympy__functions__special__gamma_functions__uppergamma(): from sympy.functions.special.gamma_functions import uppergamma assert _test_args(uppergamma(x, 2)) +def test_sympy__functions__special__gamma_functions__multigamma(): + from sympy.functions.special.gamma_functions import multigamma + assert _test_args(multigamma(x, 1)) + def test_sympy__functions__special__beta_functions__beta(): from sympy.functions.special.beta_functions import beta diff --git a/sympy/functions/special/tests/test_gamma_functions.py b/sympy/functions/special/tests/test_gamma_functions.py index 5adba2623a84..1c94267bee41 100644 --- a/sympy/functions/special/tests/test_gamma_functions.py +++ b/sympy/functions/special/tests/test_gamma_functions.py @@ -1,7 +1,8 @@ from sympy import ( - Symbol, gamma, I, oo, nan, zoo, factorial, sqrt, Rational, log, - polygamma, EulerGamma, pi, uppergamma, S, expand_func, loggamma, sin, - cos, O, lowergamma, exp, erf, erfc, exp_polar, harmonic, zeta,conjugate) + Symbol, Dummy, gamma, I, oo, nan, zoo, factorial, sqrt, Rational, + multigamma, log, polygamma, EulerGamma, pi, uppergamma, S, expand_func, + loggamma, sin, cos, O, lowergamma, exp, erf, erfc, exp_polar, harmonic, + zeta, conjugate) from sympy.core.expr import unchanged from sympy.core.function import ArgumentIndexError @@ -73,6 +74,15 @@ def test_gamma(): assert gamma(3*exp_polar(I*pi)/4).is_nonnegative is False assert gamma(3*exp_polar(I*pi)/4).is_extended_nonpositive is True + y = Symbol('y', nonpositive=True, integer=True) + assert gamma(y).is_real == False + y = Symbol('y', positive=True, noninteger=True) + assert gamma(y).is_real == True + + assert gamma(-1.0, evaluate=False).is_real == False + assert gamma(0, evaluate=False).is_real == False + assert gamma(-2, evaluate=False).is_real == False + def test_gamma_rewrite(): assert gamma(n).rewrite(factorial) == factorial(n - 1) @@ -413,7 +423,7 @@ def test_issue_8657(): m = Symbol('m', integer=True) o = Symbol('o', positive=True) p = Symbol('p', negative=True, integer=False) - assert gamma(n).is_real is None + assert gamma(n).is_real is False assert gamma(m).is_real is None assert gamma(o).is_real is True assert gamma(p).is_real is True @@ -447,3 +457,62 @@ def test_issue_14450(): def test_issue_14528(): k = Symbol('k', integer=True, nonpositive=True) assert isinstance(gamma(k), gamma) + +def test_multigamma(): + from sympy import Product + p = Symbol('p') + _k = Dummy('_k') + + assert multigamma(x, p).dummy_eq(pi**(p*(p - 1)/4)*\ + Product(gamma(x + (1 - _k)/2), (_k, 1, p))) + + assert conjugate(multigamma(x, p)).dummy_eq(pi**((conjugate(p) - 1)*\ + conjugate(p)/4)*Product(gamma(conjugate(x) + (1-conjugate(_k))/2), (_k, 1, p))) + assert conjugate(multigamma(x, 1)) == gamma(conjugate(x)) + + p = Symbol('p', positive=True) + assert conjugate(multigamma(x, p)).dummy_eq(pi**((p - 1)*p/4)*\ + Product(gamma(conjugate(x) + (1-conjugate(_k))/2), (_k, 1, p))) + + assert multigamma(nan, 1) == nan + assert multigamma(oo, 1).doit() == oo + + assert multigamma(1, 1) == 1 + assert multigamma(2, 1) == 1 + assert multigamma(3, 1) == 2 + + assert multigamma(102, 1) == factorial(101) + assert multigamma(Rational(1, 2), 1) == sqrt(pi) + + assert multigamma(1, 2) == pi + assert multigamma(2, 2) == pi/2 + + assert multigamma(1, 3) == zoo + assert multigamma(2, 3) == pi**2/2 + assert multigamma(3, 3) == 3*pi**2/2 + + assert multigamma(x, 1).diff(x) == gamma(x)*polygamma(0, x) + assert multigamma(x, 2).diff(x) == sqrt(pi)*gamma(x)*gamma(x - S(1)/2)*\ + polygamma(0, x) + sqrt(pi)*gamma(x)*gamma(x - S(1)/2)*polygamma(0, x - S(1)/2) + + assert multigamma(x - 1, 1).expand(func=True) == gamma(x)/(x - 1) + assert multigamma(x + 2, 1).expand(func=True, mul=False) == x*(x + 1)*\ + gamma(x) + assert multigamma(x - 1, 2).expand(func=True) == sqrt(pi)*gamma(x)*\ + gamma(x + S(1)/2)/(x**3 - 3*x**2 + 11*x/4 - S(3)/4) + assert multigamma(x - 1, 3).expand(func=True) == pi**(S(3)/2)*gamma(x)**2*\ + gamma(x + S(1)/2)/(x**5 - 6*x**4 + 55*x**3/4 - 15*x**2 + 31*x/4 - S(3)/2) + + assert multigamma(n, 1).rewrite(factorial) == factorial(n - 1) + assert multigamma(n, 2).rewrite(factorial) == sqrt(pi)*\ + factorial(n - S(3)/2)*factorial(n - 1) + assert multigamma(n, 3).rewrite(factorial) == pi**(S(3)/2)*\ + factorial(n - 2)*factorial(n - S(3)/2)*factorial(n - 1) + + assert multigamma(-S(1)/2, 3, evaluate=False).is_real == False + assert multigamma(S(1)/2, 3, evaluate=False).is_real == False + assert multigamma(0, 1, evaluate=False).is_real == False + assert multigamma(1, 3, evaluate=False).is_real == False + assert multigamma(-1.0, 3, evaluate=False).is_real == False + assert multigamma(0.7, 3, evaluate=False).is_real == True + assert multigamma(3, 3, evaluate=False).is_real == True

[ { "components": [ { "doc": "The multivariate gamma function is a generalization of the gamma function i.e,\n\n.. math::\n \\Gamma_p(z) = \\pi^{p(p-1)/4}\\prod_{k=1}^p \\Gamma[z + (1 - k)/2].\n\nSpecial case, multigamma(x, 1) = gamma(x)\n\nParameters\n==========\n\np: order or dimension of the m...

[ "test_sympy__functions__special__gamma_functions__multigamma", "test_gamma", "test_gamma_rewrite", "test_gamma_series", "test_lowergamma", "test_uppergamma", "test_polygamma", "test_polygamma_expand_func", "test_loggamma", "test_polygamma_expansion", "test_issue_8657", "test_issue_8524", "te...

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added multigamma function  #### References to other Issues or PRs  This is a new PR which was created because I made a blunder with old PR: https://github.com/sympy/sympy/pull/16822 #### Brief description of what is fixed or changed Multivariate Gamma function is added in `sympy/functions/special/gamma_functions.py` Need to discuss with mentors if this is needed or not. Will add test after finalization. #### Other comments `Multivariate Gamma function` is a generalization of `Gamma function` and is useful in multivariate statistics appearing in the probability density function of the `Wishart` and `inverse Wishart` distributions, and the `matrix variate beta` distribution. #### Release Notes   - functions - Added `multigamma` function in `sympy/functions/special/gamma_functions.py`  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/functions/special/gamma_functions.py] (definition of multigamma:) class multigamma(Function): """The multivariate gamma function is a generalization of the gamma function i.e, .. math:: \Gamma_p(z) = \pi^{p(p-1)/4}\prod_{k=1}^p \Gamma[z + (1 - k)/2]. Special case, multigamma(x, 1) = gamma(x) Parameters ========== p: order or dimension of the multivariate gamma function Examples ======== >>> from sympy import S, I, pi, oo, gamma, multigamma >>> from sympy import Symbol >>> x = Symbol('x') >>> p = Symbol('p', positive=True, integer=True) >>> multigamma(x, p) pi**(p*(p - 1)/4)*Product(gamma(-_k/2 + x + 1/2), (_k, 1, p)) Several special values are known: >>> multigamma(1, 1) 1 >>> multigamma(4, 1) 6 >>> multigamma(S(3)/2, 1) sqrt(pi)/2 Writing multigamma in terms of gamma function >>> multigamma(x, 1) gamma(x) >>> multigamma(x, 2) sqrt(pi)*gamma(x)*gamma(x - 1/2) >>> multigamma(x, 3) pi**(3/2)*gamma(x)*gamma(x - 1)*gamma(x - 1/2) See Also ======== gamma, lowergamma, uppergamma, polygamma, loggamma, digamma, trigamma sympy.functions.special.beta_functions.beta References ========== .. [1] https://en.wikipedia.org/wiki/Multivariate_gamma_function""" (definition of multigamma.fdiff:) def fdiff(self, argindex=2): (definition of multigamma.eval:) def eval(cls, x, p): (definition of multigamma._eval_conjugate:) def _eval_conjugate(self): (definition of multigamma._eval_is_real:) def _eval_is_real(self): [end of new definitions in sympy/functions/special/gamma_functions.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

pvlib__pvlib-python-718

718

pvlib/pvlib-python

0.5

3c84edd644fa4db54955e2225a183fa3e0405eb0

2019-05-13T14:43:11Z

diff --git a/ci/requirements-py35.yml b/ci/requirements-py35.yml index 65b5c76d00..5fc0077991 100644 --- a/ci/requirements-py35.yml +++ b/ci/requirements-py35.yml @@ -24,4 +24,5 @@ dependencies: - shapely # pvfactors dependency - siphon # conda-forge - pip: + - nrel-pysam - pvfactors==1.0.1 diff --git a/ci/requirements-py36.yml b/ci/requirements-py36.yml index a21bce2579..e415f67c7d 100644 --- a/ci/requirements-py36.yml +++ b/ci/requirements-py36.yml @@ -24,4 +24,5 @@ dependencies: - shapely # pvfactors dependency - siphon # conda-forge - pip: + - nrel-pysam - pvfactors==1.0.1 diff --git a/ci/requirements-py37.yml b/ci/requirements-py37.yml index 3783e8f772..1a6809fba6 100644 --- a/ci/requirements-py37.yml +++ b/ci/requirements-py37.yml @@ -24,4 +24,5 @@ dependencies: - shapely # pvfactors dependency - siphon # conda-forge - pip: + - nrel-pysam - pvfactors==1.0.1 diff --git a/docs/sphinx/source/api.rst b/docs/sphinx/source/api.rst index 8af2bf0f40..6e93dc5807 100644 --- a/docs/sphinx/source/api.rst +++ b/docs/sphinx/source/api.rst @@ -294,6 +294,14 @@ PVWatts model pvsystem.pvwatts_losses pvsystem.pvwatts_losses +Functions for fitting PV models +------------------------------- +.. autosummary:: + :toctree: generated/ + + ivtools.fit_sde_sandia + ivtools.fit_sdm_cec_sam + Other ----- diff --git a/docs/sphinx/source/whatsnew/v0.7.0.rst b/docs/sphinx/source/whatsnew/v0.7.0.rst index d9045a5cfb..9405eac906 100644 --- a/docs/sphinx/source/whatsnew/v0.7.0.rst +++ b/docs/sphinx/source/whatsnew/v0.7.0.rst @@ -104,6 +104,26 @@ Documentation ~~~~~~~~~~~~~ * Corrected docstring for `pvsystem.PVSystem.sapm` +API Changes +~~~~~~~~~~~ + + +Enhancements +~~~~~~~~~~~~ +* Add `ivtools` module to contain functions for IV model fitting. +* Add :py:func:`~pvlib.ivtools.fit_sde_sandia`, a simple method to fit + the single diode equation to an IV curve. +* Add :py:func:`~pvlib.ivtools.fit_sdm_cec_sam`, a wrapper for the CEC single + diode model fitting function '6parsolve' from NREL's System Advisor Model. + + +Bug fixes +~~~~~~~~~ + + +Testing +~~~~~~~ + Removal of prior version deprecations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * Removed `irradiance.extraradiation`. @@ -119,6 +139,7 @@ Contributors ~~~~~~~~~~~~ * Mark Campanellli (:ghuser:`markcampanelli`) * Will Holmgren (:ghuser:`wholmgren`) +* Cliff Hansen (:ghuser:`cwhanse`) * Oscar Dowson (:ghuser:`odow`) * Anton Driesse (:ghuser:`adriesse`) * Alexander Morgan (:ghuser:`alexandermorgan`) diff --git a/pvlib/__init__.py b/pvlib/__init__.py index a1fb92eadd..f4e3de4146 100644 --- a/pvlib/__init__.py +++ b/pvlib/__init__.py @@ -7,6 +7,7 @@ from pvlib import location from pvlib import solarposition from pvlib import iotools +from pvlib import ivtools from pvlib import tracking from pvlib import pvsystem from pvlib import spa diff --git a/pvlib/ivtools.py b/pvlib/ivtools.py new file mode 100644 index 0000000000..353a0b8a9a --- /dev/null +++ b/pvlib/ivtools.py @@ -0,0 +1,350 @@ +# -*- coding: utf-8 -*- +""" +Created on Fri Mar 29 10:34:10 2019 + +@author: cwhanse +""" + +import numpy as np + + +def fit_sdm_cec_sam(celltype, v_mp, i_mp, v_oc, i_sc, alpha_sc, beta_voc, + gamma_pmp, cells_in_series, temp_ref=25): + """ + Estimates parameters for the CEC single diode model (SDM) using the SAM + SDK. + + Parameters + ---------- + celltype : str + Value is one of 'monoSi', 'multiSi', 'polySi', 'cis', 'cigs', 'cdte', + 'amorphous' + v_mp : float + Voltage at maximum power point [V] + i_mp : float + Current at maximum power point [A] + v_oc : float + Open circuit voltage [V] + i_sc : float + Short circuit current [A] + alpha_sc : float + Temperature coefficient of short circuit current [A/C] + beta_voc : float + Temperature coefficient of open circuit voltage [V/C] + gamma_pmp : float + Temperature coefficient of power at maximum point point [%/C] + cells_in_series : int + Number of cells in series + temp_ref : float, default 25 + Reference temperature condition [C] + + Returns + ------- + tuple of the following elements: + + * I_L_ref : float + The light-generated current (or photocurrent) at reference + conditions [A] + + * I_o_ref : float + The dark or diode reverse saturation current at reference + conditions [A] + + * R_sh_ref : float + The shunt resistance at reference conditions, in ohms. + + * R_s : float + The series resistance at reference conditions, in ohms. + + * a_ref : float + The product of the usual diode ideality factor ``n`` (unitless), + number of cells in series ``Ns``, and cell thermal voltage at + reference conditions [V] + + * Adjust : float + The adjustment to the temperature coefficient for short circuit + current, in percent. + + Raises + ------ + ImportError if NREL-PySAM is not installed. + + RuntimeError if parameter extraction is not successful. + + Notes + ----- + Inputs ``v_mp``, ``v_oc``, ``i_mp`` and ``i_sc`` are assumed to be from a + single IV curve at constant irradiance and cell temperature. Irradiance is + not explicitly used by the fitting procedure. The irradiance level at which + the input IV curve is determined and the specified cell temperature + ``temp_ref`` are the reference conditions for the output parameters + ``I_L_ref``, ``I_o_ref``, ``R_sh_ref``, ``R_s``, ``a_ref`` and ``Adjust``. + + References + ---------- + [1] A. Dobos, "An Improved Coefficient Calculator for the California + Energy Commission 6 Parameter Photovoltaic Module Model", Journal of + Solar Energy Engineering, vol 134, 2012. + """ + + try: + from PySAM import PySSC + except ImportError: + raise ImportError("Requires NREL's PySAM package at " + "https://pypi.org/project/NREL-PySAM/.") + + datadict = {'tech_model': '6parsolve', 'financial_model': 'none', + 'celltype': celltype, 'Vmp': v_mp, + 'Imp': i_mp, 'Voc': v_oc, 'Isc': i_sc, 'alpha_isc': alpha_sc, + 'beta_voc': beta_voc, 'gamma_pmp': gamma_pmp, + 'Nser': cells_in_series, 'Tref': temp_ref} + + result = PySSC.ssc_sim_from_dict(datadict) + if result['cmod_success'] == 1: + return tuple([result[k] for k in ['Il', 'Io', 'Rsh', 'Rs', 'a', + 'Adj']]) + else: + raise RuntimeError('Parameter estimation failed') + + +def fit_sde_sandia(voltage, current, v_oc=None, i_sc=None, v_mp_i_mp=None, + vlim=0.2, ilim=0.1): + r""" + Fits the single diode equation (SDE) to an IV curve. + + Parameters + ---------- + voltage : ndarray + 1D array of `float` type containing voltage at each point on the IV + curve, increasing from 0 to ``v_oc`` inclusive [V] + + current : ndarray + 1D array of `float` type containing current at each point on the IV + curve, from ``i_sc`` to 0 inclusive [A] + + v_oc : float, default None + Open circuit voltage [V]. If not provided, ``v_oc`` is taken as the + last point in the ``voltage`` array. + + i_sc : float, default None + Short circuit current [A]. If not provided, ``i_sc`` is taken as the + first point in the ``current`` array. + + v_mp_i_mp : tuple of float, default None + Voltage, current at maximum power point in units of [V], [A]. + If not provided, the maximum power point is found at the maximum of + ``voltage`` \times ``current``. + + vlim : float, default 0.2 + Defines portion of IV curve where the exponential term in the single + diode equation can be neglected, i.e. + ``voltage`` <= ``vlim`` x ``v_oc`` [V] + + ilim : float, default 0.1 + Defines portion of the IV curve where the exponential term in the + single diode equation is signficant, approximately defined by + ``current`` < (1 - ``ilim``) x ``i_sc`` [A] + + Returns + ------- + tuple of the following elements: + + * photocurrent : float + photocurrent [A] + * saturation_current : float + dark (saturation) current [A] + * resistance_shunt : float + shunt (parallel) resistance, in ohms + * resistance_series : float + series resistance, in ohms + * nNsVth : float + product of thermal voltage ``Vth`` [V], diode ideality factor + ``n``, and number of series cells ``Ns`` + + Raises + ------ + RuntimeError if parameter extraction is not successful. + + Notes + ----- + Inputs ``voltage``, ``current``, ``v_oc``, ``i_sc`` and ``v_mp_i_mp`` are + assumed to be from a single IV curve at constant irradiance and cell + temperature. + + :py:func:`fit_single_diode_sandia` obtains values for the five parameters + for the single diode equation [1]: + + .. math:: + + I = I_{L} - I_{0} (\exp \frac{V + I R_{s}}{nNsVth} - 1) + - \frac{V + I R_{s}}{R_{sh}} + + See :py:func:`pvsystem.singlediode` for definition of the parameters. + + The extraction method [2] proceeds in six steps. + + 1. In the single diode equation, replace :math:`R_{sh} = 1/G_{p}` and + re-arrange + + .. math:: + + I = \frac{I_{L}}{1 + G_{p} R_{s}} - \frac{G_{p} V}{1 + G_{p} R_{s}} + - \frac{I_{0}}{1 + G_{p} R_{s}} (\exp(\frac{V + I R_{s}}{nNsVth}) - 1) + + 2. The linear portion of the IV curve is defined as + :math:`V \le vlim \times v_oc`. Over this portion of the IV curve, + + .. math:: + + \frac{I_{0}}{1 + G_{p} R_{s}} (\exp(\frac{V + I R_{s}}{nNsVth}) - 1) + \approx 0 + + 3. Fit the linear portion of the IV curve with a line. + + .. math:: + + I &\approx \frac{I_{L}}{1 + G_{p} R_{s}} - \frac{G_{p} V}{1 + G_{p} + R_{s}} \\ + &= \beta_{0} + \beta_{1} V + + 4. The exponential portion of the IV curve is defined by + :math:`\beta_{0} + \beta_{1} \times V - I > ilim \times i_sc`. + Over this portion of the curve, :math:`exp((V + IRs)/nNsVth) >> 1` + so that + + .. math:: + + \exp(\frac{V + I R_{s}}{nNsVth}) - 1 \approx + \exp(\frac{V + I R_{s}}{nNsVth}) + + 5. Fit the exponential portion of the IV curve. + + .. math:: + + \log(\beta_{0} - \beta_{1} V - I) + &\approx \log(\frac{I_{0}}{1 + G_{p} R_{s}} + \frac{V}{nNsVth} + + \frac{I R_{s}}{nNsVth} \\ + &= \beta_{2} + beta_{3} V + \beta_{4} I + + 6. Calculate values for ``IL, I0, Rs, Rsh,`` and ``nNsVth`` from the + regression coefficents :math:`\beta_{0}, \beta_{1}, \beta_{3}` and + :math:`\beta_{4}`. + + + References + ---------- + [1] S.R. Wenham, M.A. Green, M.E. Watt, "Applied Photovoltaics" ISBN + 0 86758 909 4 + [2] C. B. Jones, C. W. Hansen, Single Diode Parameter Extraction from + In-Field Photovoltaic I-V Curves on a Single Board Computer, 46th IEEE + Photovoltaic Specialist Conference, Chicago, IL, 2019 + """ + + # If not provided, extract v_oc, i_sc, v_mp and i_mp from the IV curve data + if v_oc is None: + v_oc = voltage[-1] + if i_sc is None: + i_sc = current[0] + if v_mp_i_mp is not None: + v_mp, i_mp = v_mp_i_mp + else: + v_mp, i_mp = _find_mp(voltage, current) + + # Find beta0 and beta1 from linear portion of the IV curve + beta0, beta1 = _find_beta0_beta1(voltage, current, vlim, v_oc) + + # Find beta3 and beta4 from the exponential portion of the IV curve + beta3, beta4 = _find_beta3_beta4(voltage, current, beta0, beta1, ilim, + i_sc) + + # calculate single diode parameters from regression coefficients + return _calculate_sde_parameters(beta0, beta1, beta3, beta4, v_mp, i_mp, + v_oc) + + +def _find_mp(voltage, current): + """ + Finds voltage and current at maximum power point. + + Parameters + ---------- + voltage : ndarray + 1D array containing voltage at each point on the IV curve, increasing + from 0 to v_oc inclusive, of `float` type [V] + + current : ndarray + 1D array containing current at each point on the IV curve, decreasing + from i_sc to 0 inclusive, of `float` type [A] + + Returns + ------- + v_mp, i_mp : tuple + voltage ``v_mp`` and current ``i_mp`` at the maximum power point [V], + [A] + """ + p = voltage * current + idx = np.argmax(p) + return voltage[idx], current[idx] + + +def _calc_I0(IL, I, V, Gp, Rs, nNsVth): + return (IL - I - Gp * V - Gp * Rs * I) / np.exp((V + Rs * I) / nNsVth) + + +def _find_beta0_beta1(v, i, vlim, v_oc): + # Get intercept and slope of linear portion of IV curve. + # Start with V =< vlim * v_oc, extend by adding points until slope is + # negative (downward). + beta0 = np.nan + beta1 = np.nan + first_idx = np.searchsorted(v, vlim * v_oc) + for idx in range(first_idx, len(v)): + coef = np.polyfit(v[:idx], i[:idx], deg=1) + if coef[0] < 0: + # intercept term + beta0 = coef[1].item() + # sign change of slope to get positive parameter value + beta1 = -coef[0].item() + break + if any(np.isnan([beta0, beta1])): + raise RuntimeError("Parameter extraction failed: beta0={}, beta1={}" + .format(beta0, beta1)) + else: + return beta0, beta1 + + +def _find_beta3_beta4(voltage, current, beta0, beta1, ilim, i_sc): + # Subtract the IV curve from the linear fit. + y = beta0 - beta1 * voltage - current + x = np.array([np.ones_like(voltage), voltage, current]).T + # Select points where y > ilim * i_sc to regress log(y) onto x + idx = (y > ilim * i_sc) + result = np.linalg.lstsq(x[idx], np.log(y[idx]), rcond=None) + coef = result[0] + beta3 = coef[1].item() + beta4 = coef[2].item() + if any(np.isnan([beta3, beta4])): + raise RuntimeError("Parameter extraction failed: beta3={}, beta4={}" + .format(beta3, beta4)) + else: + return beta3, beta4 + + +def _calculate_sde_parameters(beta0, beta1, beta3, beta4, v_mp, i_mp, v_oc): + nNsVth = 1.0 / beta3 + Rs = beta4 / beta3 + Gp = beta1 / (1.0 - Rs * beta1) + Rsh = 1.0 / Gp + IL = (1 + Gp * Rs) * beta0 + # calculate I0 + I0_vmp = _calc_I0(IL, i_mp, v_mp, Gp, Rs, nNsVth) + I0_voc = _calc_I0(IL, 0, v_oc, Gp, Rs, nNsVth) + if any(np.isnan([I0_vmp, I0_voc])) or ((I0_vmp <= 0) and (I0_voc <= 0)): + raise RuntimeError("Parameter extraction failed: I0 is undetermined.") + elif (I0_vmp > 0) and (I0_voc > 0): + I0 = 0.5 * (I0_vmp + I0_voc) + elif (I0_vmp > 0): + I0 = I0_vmp + else: # I0_voc > 0 + I0 = I0_voc + return (IL, I0, Rsh, Rs, nNsVth) diff --git a/setup.py b/setup.py index f2e320ccbb..a492b695e8 100755 --- a/setup.py +++ b/setup.py @@ -44,8 +44,8 @@ TESTS_REQUIRE = ['nose', 'pytest', 'pytest-cov', 'pytest-mock', 'pytest-timeout'] EXTRAS_REQUIRE = { - 'optional': ['ephem', 'cython', 'netcdf4', 'numba', 'pvfactors', 'scipy', - 'siphon', 'tables'], + 'optional': ['ephem', 'cython', 'netcdf4', 'nrel-pysam', 'numba', + 'pvfactors', 'scipy', 'siphon', 'tables'], 'doc': ['ipython', 'matplotlib', 'sphinx', 'sphinx_rtd_theme'], 'test': TESTS_REQUIRE }

diff --git a/pvlib/test/conftest.py b/pvlib/test/conftest.py index 1c690c2555..8789bf99f4 100644 --- a/pvlib/test/conftest.py +++ b/pvlib/test/conftest.py @@ -151,6 +151,15 @@ def has_numba(): reason='requires pvfactors') +try: + import PySAM # noqa: F401 + has_pysam = True +except ImportError: + has_pysam = False + +requires_pysam = pytest.mark.skipif(not has_pysam, reason="requires PySAM") + + @pytest.fixture(scope="session") def sam_data(): data = {} diff --git a/pvlib/test/test_ivtools.py b/pvlib/test/test_ivtools.py new file mode 100644 index 0000000000..d4aca050c4 --- /dev/null +++ b/pvlib/test/test_ivtools.py @@ -0,0 +1,242 @@ +# -*- coding: utf-8 -*- +""" +Created on Thu May 9 10:51:15 2019 + +@author: cwhanse +""" + +import numpy as np +import pandas as pd +import pytest +from pvlib import pvsystem +from pvlib import ivtools +from pvlib.test.conftest import requires_scipy, requires_pysam + + +@pytest.fixture +def get_test_iv_params(): + return {'IL': 8.0, 'I0': 5e-10, 'Rsh': 1000, 'Rs': 0.2, 'nNsVth': 1.61864} + + +@pytest.fixture +def get_cec_params_cansol_cs5p_220p(): + return {'input': {'V_mp_ref': 46.6, 'I_mp_ref': 4.73, 'V_oc_ref': 58.3, + 'I_sc_ref': 5.05, 'alpha_sc': 0.0025, + 'beta_voc': -0.19659, 'gamma_pmp': -0.43, + 'cells_in_series': 96}, + 'output': {'a_ref': 2.3674, 'I_L_ref': 5.056, 'I_o_ref': 1.01e-10, + 'R_sh_ref': 837.51, 'R_s': 1.004, 'Adjust': 2.3}} + + +@requires_scipy +def test_fit_sde_sandia(get_test_iv_params, get_bad_iv_curves): + test_params = get_test_iv_params + testcurve = pvsystem.singlediode(photocurrent=test_params['IL'], + saturation_current=test_params['I0'], + resistance_shunt=test_params['Rsh'], + resistance_series=test_params['Rs'], + nNsVth=test_params['nNsVth'], + ivcurve_pnts=300) + expected = tuple(test_params[k] for k in ['IL', 'I0', 'Rsh', 'Rs', + 'nNsVth']) + result = ivtools.fit_sde_sandia(voltage=testcurve['v'], + current=testcurve['i']) + assert np.allclose(result, expected, rtol=5e-5) + result = ivtools.fit_sde_sandia(voltage=testcurve['v'], + current=testcurve['i'], + v_oc=testcurve['v_oc'], + i_sc=testcurve['i_sc']) + assert np.allclose(result, expected, rtol=5e-5) + result = ivtools.fit_sde_sandia(voltage=testcurve['v'], + current=testcurve['i'], + v_oc=testcurve['v_oc'], + i_sc=testcurve['i_sc'], + v_mp_i_mp=(testcurve['v_mp'], + testcurve['i_mp'])) + assert np.allclose(result, expected, rtol=5e-5) + result = ivtools.fit_sde_sandia(voltage=testcurve['v'], + current=testcurve['i'], vlim=0.1) + assert np.allclose(result, expected, rtol=5e-5) + + +@requires_scipy +def test_fit_sde_sandia_bad_iv(get_bad_iv_curves): + # bad IV curves for coverage of if/then in _calculate_sde_parameters + v1, i1, v2, i2 = get_bad_iv_curves + result = ivtools.fit_sde_sandia(voltage=v1, current=i1) + assert np.allclose(result, (-2.4322856072799985, 8.854688976836396, + -63.56227601452038, 111.18558915546389, + -137.9965046659527)) + result = ivtools.fit_sde_sandia(voltage=v2, current=i2) + assert np.allclose(result, (2.62405311949227, 1.8657963912925288, + 110.35202827739991, -65.652554411442, + 174.49362093001415)) + + +@requires_pysam +def test_fit_sdm_cec_sam(get_cec_params_cansol_cs5p_220p): + input_data = get_cec_params_cansol_cs5p_220p['input'] + I_L_ref, I_o_ref, R_sh_ref, R_s, a_ref, Adjust = \ + ivtools.fit_sdm_cec_sam( + celltype='polySi', v_mp=input_data['V_mp_ref'], + i_mp=input_data['I_mp_ref'], v_oc=input_data['V_oc_ref'], + i_sc=input_data['I_sc_ref'], alpha_sc=input_data['alpha_sc'], + beta_voc=input_data['beta_voc'], + gamma_pmp=input_data['gamma_pmp'], + cells_in_series=input_data['cells_in_series']) + expected = pd.Series(get_cec_params_cansol_cs5p_220p['output']) + modeled = pd.Series(index=expected.index, data=np.nan) + modeled['a_ref'] = a_ref + modeled['I_L_ref'] = I_L_ref + modeled['I_o_ref'] = I_o_ref + modeled['R_sh_ref'] = R_sh_ref + modeled['R_s'] = R_s + modeled['Adjust'] = Adjust + assert np.allclose(modeled.values, expected.values, rtol=5e-2) + # test for fitting failure + with pytest.raises(RuntimeError): + I_L_ref, I_o_ref, R_sh_ref, R_s, a_ref, Adjust = \ + ivtools.fit_sdm_cec_sam( + celltype='polySi', v_mp=0.45, i_mp=5.25, v_oc=0.55, i_sc=5.5, + alpha_sc=0.00275, beta_voc=0.00275, gamma_pmp=0.0055, + cells_in_series=1, temp_ref=25) + + +@pytest.fixture +def get_bad_iv_curves(): + # v1, i1 produces a bad value for I0_voc + v1 = np.array([0, 0.338798867469060, 0.677597734938121, 1.01639660240718, + 1.35519546987624, 1.69399433734530, 2.03279320481436, + 2.37159207228342, 2.71039093975248, 3.04918980722154, + 3.38798867469060, 3.72678754215966, 4.06558640962873, + 4.40438527709779, 4.74318414456685, 5.08198301203591, + 5.42078187950497, 5.75958074697403, 6.09837961444309, + 6.43717848191215, 6.77597734938121, 7.11477621685027, + 7.45357508431933, 7.79237395178839, 8.13117281925745, + 8.46997168672651, 8.80877055419557, 9.14756942166463, + 9.48636828913369, 9.82516715660275, 10.1639660240718, + 10.5027648915409, 10.8415637590099, 11.1803626264790, + 11.5191614939481, 11.8579603614171, 12.1967592288862, + 12.5355580963552, 12.8743569638243, 13.2131558312934, + 13.5519546987624, 13.8907535662315, 14.2295524337005, + 14.5683513011696, 14.9071501686387, 15.2459490361077, + 15.5847479035768, 15.9235467710458, 16.2623456385149, + 16.6011445059840, 16.9399433734530, 17.2787422409221, + 17.6175411083911, 17.9563399758602, 18.2951388433293, + 18.6339377107983, 18.9727365782674, 19.3115354457364, + 19.6503343132055, 19.9891331806746, 20.3279320481436, + 20.6667309156127, 21.0055297830817, 21.3443286505508, + 21.6831275180199, 22.0219263854889, 22.3607252529580, + 22.6995241204270, 23.0383229878961, 23.3771218553652, + 23.7159207228342, 24.0547195903033, 24.3935184577724, + 24.7323173252414, 25.0711161927105, 25.4099150601795, + 25.7487139276486, 26.0875127951177, 26.4263116625867, + 26.7651105300558, 27.1039093975248, 27.4427082649939, + 27.7815071324630, 28.1203059999320, 28.4591048674011, + 28.7979037348701, 29.1367026023392, 29.4755014698083, + 29.8143003372773, 30.1530992047464, 30.4918980722154, + 30.8306969396845, 31.1694958071536, 31.5082946746226, + 31.8470935420917, 32.1858924095607, 32.5246912770298, + 32.8634901444989, 33.2022890119679, 33.5410878794370]) + i1 = np.array([3.39430882774470, 2.80864492110761, 3.28358165429196, + 3.41191190551673, 3.11975662808148, 3.35436585834612, + 3.23953272899809, 3.60307083325333, 2.80478101508277, + 2.80505102853845, 3.16918996870373, 3.21088388439857, + 3.46332865310431, 3.09224155015883, 3.17541550741062, + 3.32470179290389, 3.33224664316240, 3.07709000050741, + 2.89141245343405, 3.01365768561537, 3.23265176770231, + 3.32253647634228, 2.97900657569736, 3.31959549243966, + 3.03375461550111, 2.97579298978937, 3.25432831375159, + 2.89178382564454, 3.00341909207567, 3.72637492250097, + 3.28379856976360, 2.96516169245835, 3.25658381110230, + 3.41655911533139, 3.02718097944604, 3.11458376760376, + 3.24617304369762, 3.45935502367636, 3.21557333256913, + 3.27611176482650, 2.86954135732485, 3.32416319254657, + 3.15277467598732, 3.08272557013770, 3.15602202666259, + 3.49432799877150, 3.53863997177632, 3.10602611478455, + 3.05373911151821, 3.09876772570781, 2.97417228624287, + 2.84573593699237, 3.16288578405195, 3.06533173612783, + 3.02118336639575, 3.34374977225502, 2.97255164138821, + 3.19286135682863, 3.10999753817133, 3.26925354620079, + 3.11957809501529, 3.20155017481720, 3.31724984405837, + 3.42879043512927, 3.17933067619240, 3.47777362613969, + 3.20708912539777, 3.48205761174907, 3.16804363684327, + 3.14055472378230, 3.13445657434470, 2.91152696252998, + 3.10984113847427, 2.80443349399489, 3.23146278164875, + 2.94521083406108, 3.17388903141715, 3.05930294897030, + 3.18985234673287, 3.27946609274898, 3.33717523113602, + 2.76394303462702, 3.19375132937510, 2.82628616689450, + 2.85238527394143, 2.82975892599489, 2.79196912313914, + 2.72860792049395, 2.75585977414140, 2.44280222448805, + 2.36052347370628, 2.26785071765738, 2.10868255743462, + 2.06165739407987, 1.90047259509385, 1.39925575828709, + 1.24749015957606, 0.867823806536762, 0.432752457749993, 0]) + # v2, i2 produces a bad value for I0_vmp + v2 = np.array([0, 0.365686097622586, 0.731372195245173, 1.09705829286776, + 1.46274439049035, 1.82843048811293, 2.19411658573552, + 2.55980268335810, 2.92548878098069, 3.29117487860328, + 3.65686097622586, 4.02254707384845, 4.38823317147104, + 4.75391926909362, 5.11960536671621, 5.48529146433880, + 5.85097756196138, 6.21666365958397, 6.58234975720655, + 6.94803585482914, 7.31372195245173, 7.67940805007431, + 8.04509414769690, 8.41078024531949, 8.77646634294207, + 9.14215244056466, 9.50783853818725, 9.87352463580983, + 10.2392107334324, 10.6048968310550, 10.9705829286776, + 11.3362690263002, 11.7019551239228, 12.0676412215454, + 12.4333273191679, 12.7990134167905, 13.1646995144131, + 13.5303856120357, 13.8960717096583, 14.2617578072809, + 14.6274439049035, 14.9931300025260, 15.3588161001486, + 15.7245021977712, 16.0901882953938, 16.4558743930164, + 16.8215604906390, 17.1872465882616, 17.5529326858841, + 17.9186187835067, 18.2843048811293, 18.6499909787519, + 19.0156770763745, 19.3813631739971, 19.7470492716197, + 20.1127353692422, 20.4784214668648, 20.8441075644874, + 21.2097936621100, 21.5754797597326, 21.9411658573552, + 22.3068519549778, 22.6725380526004, 23.0382241502229, + 23.4039102478455, 23.7695963454681, 24.1352824430907, + 24.5009685407133, 24.8666546383359, 25.2323407359585, + 25.5980268335810, 25.9637129312036, 26.3293990288262, + 26.6950851264488, 27.0607712240714, 27.4264573216940, + 27.7921434193166, 28.1578295169392, 28.5235156145617, + 28.8892017121843, 29.2548878098069, 29.6205739074295, + 29.9862600050521, 30.3519461026747, 30.7176322002973, + 31.0833182979198, 31.4490043955424, 31.8146904931650, + 32.1803765907876, 32.5460626884102, 32.9117487860328, + 33.2774348836554, 33.6431209812779, 34.0088070789005, + 34.3744931765231, 34.7401792741457, 35.1058653717683, + 35.4715514693909, 35.8372375670135, 36.2029236646360]) + i2 = np.array([6.49218806928330, 6.49139336899548, 6.17810697175204, + 6.75197816263663, 6.59529074137515, 6.18164578868300, + 6.38709397931910, 6.30685422248427, 6.44640615548925, + 6.88727230397772, 6.42074852785591, 6.46348580823746, + 6.38642309763941, 5.66356277572311, 6.61010381702082, + 6.33288284311125, 6.22475343933610, 6.30651399433833, + 6.44435022944051, 6.43741711131908, 6.03536180208946, + 6.23814639328170, 5.97229140403242, 6.20790000748341, + 6.22933550182341, 6.22992127804882, 6.13400871899299, + 6.83491312449950, 6.07952797245846, 6.35837746415450, + 6.41972128662324, 6.85256717258275, 6.25807797296759, + 6.25124948151766, 6.22229212812413, 6.72249444167406, + 6.41085549981649, 6.75792874870056, 6.22096181559171, + 6.47839564388996, 6.56010208597432, 6.63300966556949, + 6.34617546039339, 6.79812221146153, 6.14486056194136, + 6.14979256889311, 6.16883037644880, 6.57309183229605, + 6.40064681038509, 6.18861448239873, 6.91340138179698, + 5.94164388433788, 6.23638991745862, 6.31898940411710, + 6.45247884556830, 6.58081455524297, 6.64915284801713, + 6.07122119270245, 6.41398258148256, 6.62144271089614, + 6.36377197712687, 6.51487678829345, 6.53418950147730, + 6.18886469125371, 6.26341063475750, 6.83488211680259, + 6.62699397226695, 6.41286837534735, 6.44060085001851, + 6.48114130629288, 6.18607038456406, 6.16923370572396, + 6.64223126283631, 6.07231852289266, 5.79043710204375, + 6.48463886529882, 6.36263392044401, 6.11212476454494, + 6.14573900812925, 6.12568047243240, 6.43836230231577, + 6.02505694060219, 6.13819468942244, 6.22100593815064, + 6.02394682666345, 5.89016573063789, 5.74448527739202, + 5.50415294280017, 5.31883018164157, 4.87476769510305, + 4.74386713755523, 4.60638346931628, 4.06177345572680, + 3.73334482123538, 3.13848311672243, 2.71638862600768, + 2.02963773590165, 1.49291145092070, 0.818343889647352, 0]) + + return v1, i1, v2, i2

diff --git a/ci/requirements-py35.yml b/ci/requirements-py35.yml index 65b5c76d00..5fc0077991 100644 --- a/ci/requirements-py35.yml +++ b/ci/requirements-py35.yml @@ -24,4 +24,5 @@ dependencies: - shapely # pvfactors dependency - siphon # conda-forge - pip: + - nrel-pysam - pvfactors==1.0.1 diff --git a/ci/requirements-py36.yml b/ci/requirements-py36.yml index a21bce2579..e415f67c7d 100644 --- a/ci/requirements-py36.yml +++ b/ci/requirements-py36.yml @@ -24,4 +24,5 @@ dependencies: - shapely # pvfactors dependency - siphon # conda-forge - pip: + - nrel-pysam - pvfactors==1.0.1 diff --git a/ci/requirements-py37.yml b/ci/requirements-py37.yml index 3783e8f772..1a6809fba6 100644 --- a/ci/requirements-py37.yml +++ b/ci/requirements-py37.yml @@ -24,4 +24,5 @@ dependencies: - shapely # pvfactors dependency - siphon # conda-forge - pip: + - nrel-pysam - pvfactors==1.0.1 diff --git a/docs/sphinx/source/api.rst b/docs/sphinx/source/api.rst index 8af2bf0f40..6e93dc5807 100644 --- a/docs/sphinx/source/api.rst +++ b/docs/sphinx/source/api.rst @@ -294,6 +294,14 @@ PVWatts model pvsystem.pvwatts_losses pvsystem.pvwatts_losses +Functions for fitting PV models +------------------------------- +.. autosummary:: + :toctree: generated/ + + ivtools.fit_sde_sandia + ivtools.fit_sdm_cec_sam + Other ----- diff --git a/docs/sphinx/source/whatsnew/v0.7.0.rst b/docs/sphinx/source/whatsnew/v0.7.0.rst index d9045a5cfb..9405eac906 100644 --- a/docs/sphinx/source/whatsnew/v0.7.0.rst +++ b/docs/sphinx/source/whatsnew/v0.7.0.rst @@ -104,6 +104,26 @@ Documentation ~~~~~~~~~~~~~ * Corrected docstring for `pvsystem.PVSystem.sapm` +API Changes +~~~~~~~~~~~ + + +Enhancements +~~~~~~~~~~~~ +* Add `ivtools` module to contain functions for IV model fitting. +* Add :py:func:`~pvlib.ivtools.fit_sde_sandia`, a simple method to fit + the single diode equation to an IV curve. +* Add :py:func:`~pvlib.ivtools.fit_sdm_cec_sam`, a wrapper for the CEC single + diode model fitting function '6parsolve' from NREL's System Advisor Model. + + +Bug fixes +~~~~~~~~~ + + +Testing +~~~~~~~ + Removal of prior version deprecations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * Removed `irradiance.extraradiation`. @@ -119,6 +139,7 @@ Contributors ~~~~~~~~~~~~ * Mark Campanellli (:ghuser:`markcampanelli`) * Will Holmgren (:ghuser:`wholmgren`) +* Cliff Hansen (:ghuser:`cwhanse`) * Oscar Dowson (:ghuser:`odow`) * Anton Driesse (:ghuser:`adriesse`) * Alexander Morgan (:ghuser:`alexandermorgan`)

[ { "components": [ { "doc": "Estimates parameters for the CEC single diode model (SDM) using the SAM\nSDK.\n\nParameters\n----------\ncelltype : str\n Value is one of 'monoSi', 'multiSi', 'polySi', 'cis', 'cigs', 'cdte',\n 'amorphous'\nv_mp : float\n Voltage at maximum power point [V]\ni_m...

[ "pvlib/test/test_ivtools.py::test_fit_sde_sandia", "pvlib/test/test_ivtools.py::test_fit_sde_sandia_bad_iv" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Create ivtools pvlib python pull request guidelines ==================================== Thank you for your contribution to pvlib python! You may delete all of these instructions except for the list below. You may submit a pull request with your code at any stage of completion. The following items must be addressed before the code can be merged. Please don't hesitate to ask for help if you're unsure of how to accomplish any of the items below: - [x] Closes #511 - [x] I am familiar with the [contributing guidelines](http://pvlib-python.readthedocs.io/en/latest/contributing.html). - [x] Fully tested. Added and/or modified tests to ensure correct behavior for all reasonable inputs. Tests (usually) must pass on the TravisCI and Appveyor testing services. - [x] Updates entries to `docs/sphinx/source/api.rst` for API changes. - [x] Adds description and name entries in the appropriate `docs/sphinx/source/whatsnew` file for all changes. - [x] Code quality and style is sufficient. Passes LGTM and SticklerCI checks. - [x] New code is fully documented. Includes sphinx/numpydoc compliant docstrings and comments in the code where necessary. - [x] Pull request is nearly complete and ready for detailed review. Brief description of the problem and proposed solution (if not already fully described in the issue linked to above): Add module ivtools with code to fit diode models and diode equations using IV curve data. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pvlib/ivtools.py] (definition of fit_sdm_cec_sam:) def fit_sdm_cec_sam(celltype, v_mp, i_mp, v_oc, i_sc, alpha_sc, beta_voc, gamma_pmp, cells_in_series, temp_ref=25): """Estimates parameters for the CEC single diode model (SDM) using the SAM SDK. Parameters ---------- celltype : str Value is one of 'monoSi', 'multiSi', 'polySi', 'cis', 'cigs', 'cdte', 'amorphous' v_mp : float Voltage at maximum power point [V] i_mp : float Current at maximum power point [A] v_oc : float Open circuit voltage [V] i_sc : float Short circuit current [A] alpha_sc : float Temperature coefficient of short circuit current [A/C] beta_voc : float Temperature coefficient of open circuit voltage [V/C] gamma_pmp : float Temperature coefficient of power at maximum point point [%/C] cells_in_series : int Number of cells in series temp_ref : float, default 25 Reference temperature condition [C] Returns ------- tuple of the following elements: * I_L_ref : float The light-generated current (or photocurrent) at reference conditions [A] * I_o_ref : float The dark or diode reverse saturation current at reference conditions [A] * R_sh_ref : float The shunt resistance at reference conditions, in ohms. * R_s : float The series resistance at reference conditions, in ohms. * a_ref : float The product of the usual diode ideality factor ``n`` (unitless), number of cells in series ``Ns``, and cell thermal voltage at reference conditions [V] * Adjust : float The adjustment to the temperature coefficient for short circuit current, in percent. Raises ------ ImportError if NREL-PySAM is not installed. RuntimeError if parameter extraction is not successful. Notes ----- Inputs ``v_mp``, ``v_oc``, ``i_mp`` and ``i_sc`` are assumed to be from a single IV curve at constant irradiance and cell temperature. Irradiance is not explicitly used by the fitting procedure. The irradiance level at which the input IV curve is determined and the specified cell temperature ``temp_ref`` are the reference conditions for the output parameters ``I_L_ref``, ``I_o_ref``, ``R_sh_ref``, ``R_s``, ``a_ref`` and ``Adjust``. References ---------- [1] A. Dobos, "An Improved Coefficient Calculator for the California Energy Commission 6 Parameter Photovoltaic Module Model", Journal of Solar Energy Engineering, vol 134, 2012.""" (definition of fit_sde_sandia:) def fit_sde_sandia(voltage, current, v_oc=None, i_sc=None, v_mp_i_mp=None, vlim=0.2, ilim=0.1): """Fits the single diode equation (SDE) to an IV curve. Parameters ---------- voltage : ndarray 1D array of `float` type containing voltage at each point on the IV curve, increasing from 0 to ``v_oc`` inclusive [V] current : ndarray 1D array of `float` type containing current at each point on the IV curve, from ``i_sc`` to 0 inclusive [A] v_oc : float, default None Open circuit voltage [V]. If not provided, ``v_oc`` is taken as the last point in the ``voltage`` array. i_sc : float, default None Short circuit current [A]. If not provided, ``i_sc`` is taken as the first point in the ``current`` array. v_mp_i_mp : tuple of float, default None Voltage, current at maximum power point in units of [V], [A]. If not provided, the maximum power point is found at the maximum of ``voltage`` \times ``current``. vlim : float, default 0.2 Defines portion of IV curve where the exponential term in the single diode equation can be neglected, i.e. ``voltage`` <= ``vlim`` x ``v_oc`` [V] ilim : float, default 0.1 Defines portion of the IV curve where the exponential term in the single diode equation is signficant, approximately defined by ``current`` < (1 - ``ilim``) x ``i_sc`` [A] Returns ------- tuple of the following elements: * photocurrent : float photocurrent [A] * saturation_current : float dark (saturation) current [A] * resistance_shunt : float shunt (parallel) resistance, in ohms * resistance_series : float series resistance, in ohms * nNsVth : float product of thermal voltage ``Vth`` [V], diode ideality factor ``n``, and number of series cells ``Ns`` Raises ------ RuntimeError if parameter extraction is not successful. Notes ----- Inputs ``voltage``, ``current``, ``v_oc``, ``i_sc`` and ``v_mp_i_mp`` are assumed to be from a single IV curve at constant irradiance and cell temperature. :py:func:`fit_single_diode_sandia` obtains values for the five parameters for the single diode equation [1]: .. math:: I = I_{L} - I_{0} (\exp \frac{V + I R_{s}}{nNsVth} - 1) - \frac{V + I R_{s}}{R_{sh}} See :py:func:`pvsystem.singlediode` for definition of the parameters. The extraction method [2] proceeds in six steps. 1. In the single diode equation, replace :math:`R_{sh} = 1/G_{p}` and re-arrange .. math:: I = \frac{I_{L}}{1 + G_{p} R_{s}} - \frac{G_{p} V}{1 + G_{p} R_{s}} - \frac{I_{0}}{1 + G_{p} R_{s}} (\exp(\frac{V + I R_{s}}{nNsVth}) - 1) 2. The linear portion of the IV curve is defined as :math:`V \le vlim \times v_oc`. Over this portion of the IV curve, .. math:: \frac{I_{0}}{1 + G_{p} R_{s}} (\exp(\frac{V + I R_{s}}{nNsVth}) - 1) \approx 0 3. Fit the linear portion of the IV curve with a line. .. math:: I &\approx \frac{I_{L}}{1 + G_{p} R_{s}} - \frac{G_{p} V}{1 + G_{p} R_{s}} \\ &= \beta_{0} + \beta_{1} V 4. The exponential portion of the IV curve is defined by :math:`\beta_{0} + \beta_{1} \times V - I > ilim \times i_sc`. Over this portion of the curve, :math:`exp((V + IRs)/nNsVth) >> 1` so that .. math:: \exp(\frac{V + I R_{s}}{nNsVth}) - 1 \approx \exp(\frac{V + I R_{s}}{nNsVth}) 5. Fit the exponential portion of the IV curve. .. math:: \log(\beta_{0} - \beta_{1} V - I) &\approx \log(\frac{I_{0}}{1 + G_{p} R_{s}} + \frac{V}{nNsVth} + \frac{I R_{s}}{nNsVth} \\ &= \beta_{2} + beta_{3} V + \beta_{4} I 6. Calculate values for ``IL, I0, Rs, Rsh,`` and ``nNsVth`` from the regression coefficents :math:`\beta_{0}, \beta_{1}, \beta_{3}` and :math:`\beta_{4}`. References ---------- [1] S.R. Wenham, M.A. Green, M.E. Watt, "Applied Photovoltaics" ISBN 0 86758 909 4 [2] C. B. Jones, C. W. Hansen, Single Diode Parameter Extraction from In-Field Photovoltaic I-V Curves on a Single Board Computer, 46th IEEE Photovoltaic Specialist Conference, Chicago, IL, 2019""" (definition of _find_mp:) def _find_mp(voltage, current): """Finds voltage and current at maximum power point. Parameters ---------- voltage : ndarray 1D array containing voltage at each point on the IV curve, increasing from 0 to v_oc inclusive, of `float` type [V] current : ndarray 1D array containing current at each point on the IV curve, decreasing from i_sc to 0 inclusive, of `float` type [A] Returns ------- v_mp, i_mp : tuple voltage ``v_mp`` and current ``i_mp`` at the maximum power point [V], [A]""" (definition of _calc_I0:) def _calc_I0(IL, I, V, Gp, Rs, nNsVth): (definition of _find_beta0_beta1:) def _find_beta0_beta1(v, i, vlim, v_oc): (definition of _find_beta3_beta4:) def _find_beta3_beta4(voltage, current, beta0, beta1, ilim, i_sc): (definition of _calculate_sde_parameters:) def _calculate_sde_parameters(beta0, beta1, beta3, beta4, v_mp, i_mp, v_oc): [end of new definitions in pvlib/ivtools.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> CEC 6-parameter coefficient generation SAM is able to extract the CEC parameters required for calcparams_desoto. This is done through the 'CEC Performance Model with User Entered Specifications' module model, and coefficients are automatically extracted given nameplate parameters Voc, Isc, Imp, Vmp and TempCoeff. The method is based on Aron Dobos' "An Improved Coefficient Calculator for the California Energy Commission 6 Parameter Photovoltaic Module Model ", 2012 Ideally we should be able to work with the SAM open source code, extract the bit that does the coefficient generation, and put it into a PVLib function that would allow users to run calcparams_desoto with any arbitrary module type. At the moment we are dependent on PV modules loaded into the SAM or CEC database. Thank you! ---------- SAM solution routine is located at https://github.com/NREL/ssc/blob/develop/shared/6par_solve.h , function "solve_with_sanity_and_heuristics" . Additional dependencies on other files 6par_newton.h, 6par_search.h, 6par_jacobian.h, 6par_lu.h, 6par_gamma.h, all located in https://github.com/NREL/ssc/tree/develop/shared . I'd like to try to take this up sometime soon, maybe by the end of the year? Is anyone else working on it? I haven't seen a PR. Does anyone have any strong opinions? Is seems like there's a SAM implementation, is there a PVLIB-MATLAB version already? thx I'm not working on it. If it is practical, it would be great to wrap the SAM method. NREL put a lot of effort into the heuristics for initial values and updating. We have a function in PVLib for MATLAB but it's a very different algorithm. For consistency with the parameter databases it would be better to use the SAM algorithm. Do I read between the lines that the two algorithms do not converge on the same parameters? Then it would be of great interest to have python implementations of each! Or perhaps even more important: documents describing the full algorithms along with every heuristic, assumption and constraint they implement... @adriesse yes. Each model fitting algorithm I'm aware of, will produce different parameter values from the same data although the predicted IV curves may be similar. FWIW I am trying to establish a common/fair metric to compare different model fits in PVfit. In addition to choosing, say, which residual(s) to analyze, the effect of model discrepancy significantly affects such comparisons. PVfit’s orthogonal distance regression (ODR) fits to the single-diode model (SDM) often are worse than other algorithms’ fits in terms of terminal current residuals, but I have observed consistently that this is likely due to model discrepancy. One might claim that ODR is being more “honest” here, but I think it really means that the model should be improved. Note that PVfit’s ODR alternatively optimizes the residual of the sum of currents at the high-voltage diode node in the equivalent-circuit model, and it doesn’t make unfounded assumptions about error-free measurements in all data channels except the terminal current (which also has implications for parameter non-identifiability). I have seen plenty of evidence that ODR fits are “good” in the absence of significant model discrepancy, such as for some (but not all!) double-diode model (DDM) fits across various material systems. > If it is practical, it would be great to wrap the SAM method. Two kinds of practicalities here: 1. Technical. I don't know how to do it but I am sure it's possible. I am ok with it so long as pvlib remains straightforward to install from source. 2. Legal. We would need assurance from NREL that it's ok for pvlib to distribute this SAM code under the terms of a MIT license rather than SAM's mixed MIT/GPL license. In the next 6-8 months, the NREL team will be updating our python wrapper for the SAM software development kit so that you can pip install the sam-sdk and call its routines in a much more native pythonic fashion. That might be a quick way to implement the CEC parameter generation to solve both the technical and legal practicalities Will mentions above, as well as the many file dependencies involved with that routine. The SDK is licensed separately from the SAM open source code under an MIT type license, so that distribution with pvlib would be ok, and once we have it set up as a python package, that should make it a non-issue to include with pvlib installation from source. To @adriesse 's point, the publication associated with the method implemented in SAM is here: http://solarenergyengineering.asmedigitalcollection.asme.org/article.aspx?articleid=1458865 Thanks @janinefreeman that is great news! @janinefreeman Does NREL's web site no longer provide free preprints of Aron's paper? @thunderfish24 I'm not finding a copy of it in NREL's pubs database, but it looks like you may be able to get it here (didn't create an account to give it a try): https://www.osti.gov/biblio/1043759 @thunderfish24 I sent you a preprint. -------------------- </issues>

3c84edd644fa4db54955e2225a183fa3e0405eb0

sympy__sympy-16825

16,825

sympy/sympy

1.5

6ffc2f04ad820e3f592b2107e66a16fd4585ac02

2019-05-13T12:06:41Z

diff --git a/sympy/stats/joint_rv_types.py b/sympy/stats/joint_rv_types.py index 224e3f0b9230..f7614a0beb81 100644 --- a/sympy/stats/joint_rv_types.py +++ b/sympy/stats/joint_rv_types.py @@ -1,6 +1,7 @@ from sympy import (sympify, S, pi, sqrt, exp, Lambda, Indexed, Gt, IndexedBase, besselk, gamma, Interval, Range, factorial, Mul, Integer, - Add, rf, Eq, Piecewise, Symbol, imageset, Intersection) + Add, rf, Eq, Piecewise, ones, Symbol, Pow, Rational, Sum, + imageset, Intersection, Matrix) from sympy.matrices import ImmutableMatrix from sympy.matrices.expressions.determinant import det from sympy.stats.joint_rv import (JointDistribution, JointPSpace, @@ -394,6 +395,161 @@ def MultivariateEwens(syms, n, theta): """ return multivariate_rv(MultivariateEwensDistribution, syms, n, theta) +#------------------------------------------------------------------------------- +# Generalized Multivariate Log Gamma distribution --------------------------------------------------------- + +class GeneralizedMultivariateLogGammaDistribution(JointDistribution): + + _argnames = ['delta', 'v', 'lamda', 'mu'] + is_Continuous=True + + def check(self, delta, v, l, mu): + _value_check((delta >= 0, delta <= 1), "delta must be in range [0, 1].") + _value_check((v > 0), "v must be positive") + for lk in l: + _value_check((lk > 0), "lamda must be a positive vector.") + for muk in mu: + _value_check((muk > 0), "mu must be a positive vector.") + _value_check(len(l) > 1,"the distribution should have at least" + " two random variables.") + + @property + def set(self): + from sympy.sets.sets import Interval + return S.Reals**len(self.lamda) + + def pdf(self, *y): + from sympy.functions.special.gamma_functions import gamma + d, v, l, mu = self.delta, self.v, self.lamda, self.mu + n = Symbol('n', negative=False, integer=True) + k = len(l) + sterm1 = Pow((1 - d), n)/\ + ((gamma(v + n)**(k - 1))*gamma(v)*gamma(n + 1)) + sterm2 = Mul.fromiter([mui*li**(-v - n) for mui, li in zip(mu, l)]) + term1 = sterm1 * sterm2 + sterm3 = (v + n) * sum([mui * yi for mui, yi in zip(mu, y)]) + sterm4 = sum([exp(mui * yi)/li for (mui, yi, li) in zip(mu, y, l)]) + term2 = exp(sterm3 - sterm4) + return Pow(d, v) * Sum(term1 * term2, (n, 0, S.Infinity)) + +def GeneralizedMultivariateLogGamma(syms, delta, v, lamda, mu): + """ + Creates a joint random variable with generalized multivariate log gamma + distribution. + + The joint pdf can be found at [1]. + + Parameters + ========== + + syms: list/tuple/set of symbols for identifying each component + delta: A constant in range [0, 1] + v: positive real + lamda: a list of positive reals + mu: a list of positive reals + + Returns + ======= + + A Random Symbol + + Examples + ======== + + >>> from sympy.stats import density + >>> from sympy.stats.joint_rv import marginal_distribution + >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma + >>> from sympy import symbols, S + >>> v = 1 + >>> l, mu = [1, 1, 1], [1, 1, 1] + >>> d = S.Half + >>> y = symbols('y_1:4', positive=True) + >>> Gd = GeneralizedMultivariateLogGamma('G', d, v, l, mu) + >>> density(Gd)(y[0], y[1], y[2]) + Sum(2**(-n)*exp((n + 1)*(y_1 + y_2 + y_3) - exp(y_1) - exp(y_2) - + exp(y_3))/gamma(n + 1)**3, (n, 0, oo))/2 + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Generalized_multivariate_log-gamma_distribution + .. [2] https://www.researchgate.net/publication/234137346_On_a_multivariate_log-gamma_distribution_and_the_use_of_the_distribution_in_the_Bayesian_analysis + + Note + ==== + + If the GeneralizedMultivariateLogGamma is too long to type use, + `from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma as GMVLG` + If you want to pass the matrix omega instead of the constant delta, then use, + GeneralizedMultivariateLogGammaOmega. + + """ + return multivariate_rv(GeneralizedMultivariateLogGammaDistribution, + syms, delta, v, lamda, mu) + +def GeneralizedMultivariateLogGammaOmega(syms, omega, v, lamda, mu): + """ + Extends GeneralizedMultivariateLogGamma. + + Parameters + ========== + + syms: list/tuple/set of symbols for identifying each component + omega: A square matrix + Every element of square matrix must be absolute value of + sqaure root of correlation coefficient + v: positive real + lamda: a list of positive reals + mu: a list of positive reals + + Returns + ======= + + A Random Symbol + + Examples + ======== + + >>> from sympy.stats import density + >>> from sympy.stats.joint_rv import marginal_distribution + >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega + >>> from sympy import Matrix, symbols, S + >>> omega = Matrix([[1, S.Half, S.Half], [S.Half, 1, S.Half], [S.Half, S.Half, 1]]) + >>> v = 1 + >>> l, mu = [1, 1, 1], [1, 1, 1] + >>> G = GeneralizedMultivariateLogGammaOmega('G', omega, v, l, mu) + >>> y = symbols('y_1:4', positive=True) + >>> density(G)(y[0], y[1], y[2]) + sqrt(2)*Sum((1 - sqrt(2)/2)**n*exp((n + 1)*(y_1 + y_2 + y_3) - exp(y_1) - + exp(y_2) - exp(y_3))/gamma(n + 1)**3, (n, 0, oo))/2 + + References + ========== + + See references of GeneralizedMultivariateLogGamma. + + Notes + ===== + + If the GeneralizedMultivariateLogGammaOmega is too long to type use, + `from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega as GMVLGO` + """ + _value_check((omega.is_square, isinstance(omega, Matrix)), "omega must be a" + " square matrix") + for val in omega.values(): + _value_check((val >= 0, val <= 1), + "all values in matrix must be between 0 and 1(both inclusive).") + _value_check(omega.diagonal().equals(ones(1, omega.shape[0])), + "all the elements of diagonal should be 1.") + _value_check((omega.shape[0] == len(lamda), len(lamda) == len(mu)), + "lamda, mu should be of same length and omega should " + " be of shape (length of lamda, length of mu)") + _value_check(len(lamda) > 1,"the distribution should have at least" + " two random variables.") + delta = Pow(Rational(omega.det()), Rational(1, len(lamda) - 1)) + return GeneralizedMultivariateLogGamma(syms, delta, v, lamda, mu) + + #------------------------------------------------------------------------------- # Multinomial distribution ---------------------------------------------------------

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 098a0a559ca2..722bf012b762 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1501,6 +1501,11 @@ def test_sympy__stats__joint_rv_types__NormalGammaDistribution(): from sympy.stats.joint_rv_types import NormalGammaDistribution assert _test_args(NormalGammaDistribution(1, 2, 3, 4)) +def test_sympy__stats__joint_rv_types__GeneralizedMultivariateLogGammaDistribution(): + from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaDistribution + v, l, mu = (4, [1, 2, 3, 4], [1, 2, 3, 4]) + assert _test_args(GeneralizedMultivariateLogGammaDistribution(S.Half, v, l, mu)) + def test_sympy__stats__joint_rv_types__MultivariateBetaDistribution(): from sympy.stats.joint_rv_types import MultivariateBetaDistribution assert _test_args(MultivariateBetaDistribution([1, 2, 3])) diff --git a/sympy/stats/tests/test_joint_rv.py b/sympy/stats/tests/test_joint_rv.py index 71f18a1123a0..0bb5ac95562c 100644 --- a/sympy/stats/tests/test_joint_rv.py +++ b/sympy/stats/tests/test_joint_rv.py @@ -1,5 +1,5 @@ -from sympy import (symbols, pi, oo, S, exp, sqrt, besselk, Indexed, Rational, - simplify, Piecewise, factorial, Eq, gamma, Sum) +from sympy import (symbols, pi, oo, S, exp, sqrt, besselk, Indexed, Sum, simplify, + Mul, Rational, Integral, factorial, gamma, Piecewise, Eq) from sympy.core.numbers import comp from sympy.stats import density from sympy.stats.joint_rv import marginal_distribution @@ -55,6 +55,68 @@ def test_NormalGamma(): 3*sqrt(10)*gamma(S(7)/4)/(10*sqrt(pi)*gamma(S(5)/4)) assert marginal_distribution(ng, y)(1) == exp(-S(1)/4)/128 +def test_GeneralizedMultivariateLogGammaDistribution(): + from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega as GMVLGO + from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma as GMVLG + from sympy import gamma + h = S.Half + omega = Matrix([[1, h, h, h], + [h, 1, h, h], + [h, h, 1, h], + [h, h, h, 1]]) + v, l, mu = (4, [1, 2, 3, 4], [1, 2, 3, 4]) + y_1, y_2, y_3, y_4 = symbols('y_1:5', real=True) + n = symbols('n', negative=False, integer=True) + delta = symbols('d', positive=True) + G = GMVLGO('G', omega, v, l, mu) + Gd = GMVLG('Gd', delta, v, l, mu) + dend = ("d**4*Sum(4*24**(-n - 4)*(1 - d)**n*exp((n + 4)*(y_1 + 2*y_2 + 3*y_3 " + "+ 4*y_4) - exp(y_1) - exp(2*y_2)/2 - exp(3*y_3)/3 - exp(4*y_4)/4)/" + "(gamma(n + 1)*gamma(n + 4)**3), (n, 0, oo))") + assert str(density(Gd)(y_1, y_2, y_3, y_4)) == dend + den = ("5*2**(2/3)*5**(1/3)*Sum(4*24**(-n - 4)*(-2**(2/3)*5**(1/3)/4 + 1)**n*" + "exp((n + 4)*(y_1 + 2*y_2 + 3*y_3 + 4*y_4) - exp(y_1) - exp(2*y_2)/2 - " + "exp(3*y_3)/3 - exp(4*y_4)/4)/(gamma(n + 1)*gamma(n + 4)**3), (n, 0, oo))/64") + assert str(density(G)(y_1, y_2, y_3, y_4)) == den + marg = ("5*2**(2/3)*5**(1/3)*exp(4*y_1)*exp(-exp(y_1))*Integral(exp(-exp(4*G[3])" + "/4)*exp(16*G[3])*Integral(exp(-exp(3*G[2])/3)*exp(12*G[2])*Integral(exp(" + "-exp(2*G[1])/2)*exp(8*G[1])*Sum((-1/4)**n*24**(-n)*(-4 + 2**(2/3)*5**(1/3" + "))**n*exp(n*y_1)*exp(2*n*G[1])*exp(3*n*G[2])*exp(4*n*G[3])/(gamma(n + 1)" + "*gamma(n + 4)**3), (n, 0, oo)), (G[1], -oo, oo)), (G[2], -oo, oo)), (G[3]" + ", -oo, oo))/5308416") + assert str(marginal_distribution(G, G[0])(y_1)) == marg + omega_f1 = Matrix([[1, h, h]]) + omega_f2 = Matrix([[1, h, h, h], + [h, 1, 2, h], + [h, h, 1, h], + [h, h, h, 1]]) + omega_f3 = Matrix([[6, h, h, h], + [h, 1, 2, h], + [h, h, 1, h], + [h, h, h, 1]]) + v_f = symbols("v_f", positive=False) + l_f = [1, 2, v_f, 4] + m_f = [v_f, 2, 3, 4] + omega_f4 = Matrix([[1, h, h, h, h], + [h, 1, h, h, h], + [h, h, 1, h, h], + [h, h, h, 1, h], + [h, h, h, h, 1]]) + l_f1 = [1, 2, 3, 4, 5] + omega_f5 = Matrix([[1]]) + mu_f5 = l_f5 = [1] + + raises(ValueError, lambda: GMVLGO('G', omega_f1, v, l, mu)) + raises(ValueError, lambda: GMVLGO('G', omega_f2, v, l, mu)) + raises(ValueError, lambda: GMVLGO('G', omega_f3, v, l, mu)) + raises(ValueError, lambda: GMVLGO('G', omega, v_f, l, mu)) + raises(ValueError, lambda: GMVLGO('G', omega, v, l_f, mu)) + raises(ValueError, lambda: GMVLGO('G', omega, v, l, m_f)) + raises(ValueError, lambda: GMVLGO('G', omega_f4, v, l, mu)) + raises(ValueError, lambda: GMVLGO('G', omega, v, l_f1, mu)) + raises(ValueError, lambda: GMVLGO('G', omega_f5, v, l_f5, mu_f5)) + raises(ValueError, lambda: GMVLG('G', Rational(3, 2), v, l, mu)) + def test_MultivariateBeta(): from sympy.stats.joint_rv_types import MultivariateBeta from sympy import gamma

[ { "components": [ { "doc": "", "lines": [ 401, 433 ], "name": "GeneralizedMultivariateLogGammaDistribution", "signature": "class GeneralizedMultivariateLogGammaDistribution(JointDistribution):", "type": "class" }, { "d...

[ "test_sympy__stats__joint_rv_types__GeneralizedMultivariateLogGammaDistribution", "test_GeneralizedMultivariateLogGammaDistribution" ]

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added Generalized Multivariate Log Gamma Distribution  #### References to other Issues or PRs  Extends https://github.com/sympy/sympy/pull/16576 #### Brief description of what is fixed or changed Generalized Multivariate Log Gamma Distribution has been added. #### Other comments N/A #### Release Notes   * stats * Generalized Multivariate Log Gamma Distribution has been added to `sympy.stats.joint_rv_types`  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/joint_rv_types.py] (definition of GeneralizedMultivariateLogGammaDistribution:) class GeneralizedMultivariateLogGammaDistribution(JointDistribution): (definition of GeneralizedMultivariateLogGammaDistribution.check:) def check(self, delta, v, l, mu): (definition of GeneralizedMultivariateLogGammaDistribution.set:) def set(self): (definition of GeneralizedMultivariateLogGammaDistribution.pdf:) def pdf(self, *y): (definition of GeneralizedMultivariateLogGamma:) def GeneralizedMultivariateLogGamma(syms, delta, v, lamda, mu): """Creates a joint random variable with generalized multivariate log gamma distribution. The joint pdf can be found at [1]. Parameters ========== syms: list/tuple/set of symbols for identifying each component delta: A constant in range [0, 1] v: positive real lamda: a list of positive reals mu: a list of positive reals Returns ======= A Random Symbol Examples ======== >>> from sympy.stats import density >>> from sympy.stats.joint_rv import marginal_distribution >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma >>> from sympy import symbols, S >>> v = 1 >>> l, mu = [1, 1, 1], [1, 1, 1] >>> d = S.Half >>> y = symbols('y_1:4', positive=True) >>> Gd = GeneralizedMultivariateLogGamma('G', d, v, l, mu) >>> density(Gd)(y[0], y[1], y[2]) Sum(2**(-n)*exp((n + 1)*(y_1 + y_2 + y_3) - exp(y_1) - exp(y_2) - exp(y_3))/gamma(n + 1)**3, (n, 0, oo))/2 References ========== .. [1] https://en.wikipedia.org/wiki/Generalized_multivariate_log-gamma_distribution .. [2] https://www.researchgate.net/publication/234137346_On_a_multivariate_log-gamma_distribution_and_the_use_of_the_distribution_in_the_Bayesian_analysis Note ==== If the GeneralizedMultivariateLogGamma is too long to type use, `from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma as GMVLG` If you want to pass the matrix omega instead of the constant delta, then use, GeneralizedMultivariateLogGammaOmega.""" (definition of GeneralizedMultivariateLogGammaOmega:) def GeneralizedMultivariateLogGammaOmega(syms, omega, v, lamda, mu): """Extends GeneralizedMultivariateLogGamma. Parameters ========== syms: list/tuple/set of symbols for identifying each component omega: A square matrix Every element of square matrix must be absolute value of sqaure root of correlation coefficient v: positive real lamda: a list of positive reals mu: a list of positive reals Returns ======= A Random Symbol Examples ======== >>> from sympy.stats import density >>> from sympy.stats.joint_rv import marginal_distribution >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega >>> from sympy import Matrix, symbols, S >>> omega = Matrix([[1, S.Half, S.Half], [S.Half, 1, S.Half], [S.Half, S.Half, 1]]) >>> v = 1 >>> l, mu = [1, 1, 1], [1, 1, 1] >>> G = GeneralizedMultivariateLogGammaOmega('G', omega, v, l, mu) >>> y = symbols('y_1:4', positive=True) >>> density(G)(y[0], y[1], y[2]) sqrt(2)*Sum((1 - sqrt(2)/2)**n*exp((n + 1)*(y_1 + y_2 + y_3) - exp(y_1) - exp(y_2) - exp(y_3))/gamma(n + 1)**3, (n, 0, oo))/2 References ========== See references of GeneralizedMultivariateLogGamma. Notes ===== If the GeneralizedMultivariateLogGammaOmega is too long to type use, `from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega as GMVLGO`""" [end of new definitions in sympy/stats/joint_rv_types.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-16815

16,815

sympy/sympy

1.5

20234eb7782f1f66c1f1d2a6d05f1179091add0a

2019-05-12T11:50:53Z

diff --git a/sympy/stats/__init__.py b/sympy/stats/__init__.py index ee5889933ebe..12df043bf44b 100644 --- a/sympy/stats/__init__.py +++ b/sympy/stats/__init__.py @@ -50,7 +50,7 @@ from . import frv_types from .frv_types import ( - Bernoulli, Binomial, Coin, Die, DiscreteUniform, FiniteRV, Hypergeometric, + Bernoulli, Binomial, BetaBinomial, Coin, Die, DiscreteUniform, FiniteRV, Hypergeometric, Rademacher, ) __all__.extend(frv_types.__all__) diff --git a/sympy/stats/frv_types.py b/sympy/stats/frv_types.py index 7563868e0fd3..20121985051e 100644 --- a/sympy/stats/frv_types.py +++ b/sympy/stats/frv_types.py @@ -9,6 +9,7 @@ Bernoulli Coin Binomial +BetaBinomial Hypergeometric Rademacher """ @@ -17,6 +18,7 @@ from sympy import (S, sympify, Rational, binomial, cacheit, Integer, Dict, Basic, KroneckerDelta, Dummy, Eq) +from sympy import beta as beta_fn from sympy.concrete.summations import Sum from sympy.core.compatibility import as_int, range from sympy.stats.rv import _value_check @@ -28,6 +30,7 @@ 'Bernoulli', 'Coin', 'Binomial', +'BetaBinomial', 'Hypergeometric', 'Rademacher' ] @@ -305,6 +308,56 @@ def Binomial(name, n, p, succ=1, fail=0): return rv(name, BinomialDistribution, n, p, succ, fail) +#------------------------------------------------------------------------------- +# Beta-binomial distribution ---------------------------------------------------------- + +class BetaBinomialDistribution(SingleFiniteDistribution): + _argnames = ('n', 'alpha', 'beta') + + @staticmethod + def check(n, alpha, beta): + _value_check((n.is_integer, n.is_nonnegative), + "'n' must be nonnegative integer. n = %s." % str(n)) + _value_check((alpha > 0), + "'alpha' must be: alpha > 0 . alpha = %s" % str(alpha)) + _value_check((beta > 0), + "'beta' must be: beta > 0 . beta = %s" % str(beta)) + + @property + @cacheit + def dict(self): + n, a, b = self.n, self.alpha, self.beta + n = as_int(n) + return dict((k, binomial(n, k) * beta_fn(k + a, n - k + b) / beta_fn(a, b)) + for k in range(0, n + 1)) + + +def BetaBinomial(name, n, alpha, beta): + """ + Create a Finite Random Variable representing a Beta-binomial distribution. + + Returns a RandomSymbol. + + Examples + ======== + + >>> from sympy.stats import BetaBinomial, density + >>> from sympy import S + + >>> X = BetaBinomial('X', 2, 1, 1) + >>> density(X).dict + {0: beta(1, 3)/beta(1, 1), 1: 2*beta(2, 2)/beta(1, 1), 2: beta(3, 1)/beta(1, 1)} + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Beta-binomial_distribution + .. [2] http://mathworld.wolfram.com/BetaBinomialDistribution.html + + """ + + return rv(name, BetaBinomialDistribution, n, alpha, beta) + class HypergeometricDistribution(SingleFiniteDistribution): _argnames = ('N', 'm', 'n')

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index b4912d134d17..b78927ac34e1 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1179,6 +1179,10 @@ def test_sympy__stats__frv_types__BinomialDistribution(): from sympy.stats.frv_types import BinomialDistribution assert _test_args(BinomialDistribution(5, S.Half, 1, 0)) +def test_sympy__stats__frv_types__BetaBinomialDistribution(): + from sympy.stats.frv_types import BetaBinomialDistribution + assert _test_args(BetaBinomialDistribution(5, 1, 1)) + def test_sympy__stats__frv_types__HypergeometricDistribution(): from sympy.stats.frv_types import HypergeometricDistribution diff --git a/sympy/stats/tests/test_finite_rv.py b/sympy/stats/tests/test_finite_rv.py index 8c5b37762e06..ea472c398caa 100644 --- a/sympy/stats/tests/test_finite_rv.py +++ b/sympy/stats/tests/test_finite_rv.py @@ -1,9 +1,9 @@ -from sympy import (FiniteSet, S, Symbol, sqrt, nan, +from sympy import (FiniteSet, S, Symbol, sqrt, nan, beta, symbols, simplify, Eq, cos, And, Tuple, Or, Dict, sympify, binomial, cancel, exp, I, Piecewise) from sympy.core.compatibility import range from sympy.matrices import Matrix -from sympy.stats import (DiscreteUniform, Die, Bernoulli, Coin, Binomial, +from sympy.stats import (DiscreteUniform, Die, Bernoulli, Coin, Binomial, BetaBinomial, Hypergeometric, Rademacher, P, E, variance, covariance, skewness, kurtosis, sample, density, where, FiniteRV, pspace, cdf, correlation, moment, cmoment, smoment, characteristic_function, moment_generating_function, @@ -248,6 +248,40 @@ def test_binomial_symbolic(): Y = Binomial('Y', n, p, succ=H, fail=T) assert simplify(E(Y) - (n*(H*p + T*(1 - p)))) == 0 +def test_beta_binomial(): + # verify parameters + raises(ValueError, lambda: BetaBinomial('b', .2, 1, 2)) + raises(ValueError, lambda: BetaBinomial('b', 2, -1, 2)) + raises(ValueError, lambda: BetaBinomial('b', 2, 1, -2)) + assert BetaBinomial('b', 2, 1, 1) + + # test numeric values + nvals = range(1,5) + alphavals = [S(1)/4, S.Half, S(3)/4, 1, 10] + betavals = [S(1)/4, S.Half, S(3)/4, 1, 10] + + for n in nvals: + for a in alphavals: + for b in betavals: + X = BetaBinomial('X', n, a, b) + assert E(X) == moment(X, 1) + assert variance(X) == cmoment(X, 2) + + # test symbolic + n, a, b = symbols('a b n') + assert BetaBinomial('x', n, a, b) + n = 2 # Because we're using for loops, can't do symbolic n + a, b = symbols('a b', positive=True) + X = BetaBinomial('X', n, a, b) + t = Symbol('t') + + assert E(X).expand() == moment(X, 1).expand() + assert variance(X).expand() == cmoment(X, 2).expand() + assert skewness(X) == smoment(X, 3) + assert characteristic_function(X)(t) == exp(2*I*t)*beta(a + 2, b)/beta(a, b) +\ + 2*exp(I*t)*beta(a + 1, b + 1)/beta(a, b) + beta(a, b + 2)/beta(a, b) + assert moment_generating_function(X)(t) == exp(2*t)*beta(a + 2, b)/beta(a, b) +\ + 2*exp(t)*beta(a + 1, b + 1)/beta(a, b) + beta(a, b + 2)/beta(a, b) def test_hypergeometric_numeric(): for N in range(1, 5):

[ { "components": [ { "doc": "", "lines": [ 314, 332 ], "name": "BetaBinomialDistribution", "signature": "class BetaBinomialDistribution(SingleFiniteDistribution):", "type": "class" }, { "doc": "", "lines": [ ...

[ "test_sympy__stats__frv_types__BetaBinomialDistribution", "test_discreteuniform", "test_dice", "test_given", "test_domains", "test_dice_bayes", "test_die_args", "test_bernoulli", "test_cdf", "test_coins", "test_binomial_verify_parameters", "test_binomial_numeric", "test_binomial_quantile", ...

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [GSoC] Added Beta-binomial distribution  #### References to other Issues or PRs  #### Brief description of what is fixed or changed Discrete Univariate Beta-binomial distribution added to `sympy/stats/frv_types.py`. Also added corresponding tests. This distribution will also be useful for Compound distribution module, since it is a binomial distribution with probability `p` being a RV with beta distribution. #### Other comments #### Release Notes   - stats - Added `BetaBinomial` distribution to `sympy.stats.frv_types`.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/frv_types.py] (definition of BetaBinomialDistribution:) class BetaBinomialDistribution(SingleFiniteDistribution): (definition of BetaBinomialDistribution.check:) def check(n, alpha, beta): (definition of BetaBinomialDistribution.dict:) def dict(self): (definition of BetaBinomial:) def BetaBinomial(name, n, alpha, beta): """Create a Finite Random Variable representing a Beta-binomial distribution. Returns a RandomSymbol. Examples ======== >>> from sympy.stats import BetaBinomial, density >>> from sympy import S >>> X = BetaBinomial('X', 2, 1, 1) >>> density(X).dict {0: beta(1, 3)/beta(1, 1), 1: 2*beta(2, 2)/beta(1, 1), 2: beta(3, 1)/beta(1, 1)} References ========== .. [1] https://en.wikipedia.org/wiki/Beta-binomial_distribution .. [2] http://mathworld.wolfram.com/BetaBinomialDistribution.html""" [end of new definitions in sympy/stats/frv_types.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-16814

16,814

sympy/sympy

1.5

19341137da6e3ae8fc59784f5d044412539d05e9

2019-05-12T08:57:13Z

diff --git a/sympy/stats/__init__.py b/sympy/stats/__init__.py index db7d4832713c..c38255f01257 100644 --- a/sympy/stats/__init__.py +++ b/sympy/stats/__init__.py @@ -61,9 +61,9 @@ Arcsin, Benini, Beta, BetaNoncentral, BetaPrime, Cauchy, Chi, ChiNoncentral, ChiSquared, Dagum, Erlang, Exponential, FDistribution, FisherZ, Frechet, Gamma, GammaInverse, Gumbel, Gompertz, Kumaraswamy, Laplace, Logistic, LogNormal, - Maxwell, Nakagami, Normal, Pareto, QuadraticU, RaisedCosine, Rayleigh, + Maxwell, Nakagami, Normal, GaussianInverse, Pareto, QuadraticU, RaisedCosine, Rayleigh, ShiftedGompertz, StudentT, Trapezoidal, Triangular, Uniform, UniformSum, VonMises, - Weibull, WignerSemicircle + Weibull, WignerSemicircle, Wald ) __all__.extend(crv_types.__all__) diff --git a/sympy/stats/crv_types.py b/sympy/stats/crv_types.py index 063a541742ac..047960bbd4e5 100644 --- a/sympy/stats/crv_types.py +++ b/sympy/stats/crv_types.py @@ -91,6 +91,7 @@ 'Maxwell', 'Nakagami', 'Normal', +'GaussianInverse', 'Pareto', 'QuadraticU', 'RaisedCosine', @@ -1492,7 +1493,7 @@ def sample(self): from scipy.stats import invgamma return invgamma.rvs(float(self.a), 0, float(self.b)) else: - raise NotImplementedError('Sampling the inverse Gamma Distribution requires Scipy.') + raise NotImplementedError('Sampling the Inverse Gamma Distribution requires Scipy.') def _characteristic_function(self, t): a, b = self.a, self.b @@ -2304,7 +2305,7 @@ def Normal(name, mean, std): >>> m = Normal('X', [1, 2], [[2, 1], [1, 2]]) >>> from sympy.stats.joint_rv import marginal_distribution - >>> pprint(density(m)(y, z)) + >>> pprint(density(m)(y, z), use_unicode=False) /1 y\ /2*y z\ / z\ / y 2*z \ |- - -|*|--- - -| + |1 - -|*|- - + --- - 1| ___ \2 2/ \ 3 3/ \ 2/ \ 3 3 / @@ -2331,6 +2332,120 @@ def Normal(name, mean, std): MultivariateNormalDistribution, name, mean, std) return rv(name, NormalDistribution, (mean, std)) + +#------------------------------------------------------------------------------- +# Inverse Gaussian distribution ---------------------------------------------------------- + + +class GaussianInverseDistribution(SingleContinuousDistribution): + _argnames = ('mean', 'shape') + + @property + def set(self): + return Interval(0, oo) + + @staticmethod + def check(mean, shape): + _value_check(shape > 0, "Shape parameter must be positive") + _value_check(mean > 0, "Mean must be positive") + + def pdf(self, x): + mu, s = self.mean, self.shape + return exp(-s*(x - mu)**2 / (2*x*mu**2)) * sqrt(s/((2*pi*x**3))) + + def sample(self): + scipy = import_module('scipy') + if scipy: + from scipy.stats import invgauss + return invgauss.rvs(float(self.mean/self.shape), 0, float(self.shape)) + else: + raise NotImplementedError( + 'Sampling the Inverse Gaussian Distribution requires Scipy.') + + def _cdf(self, x): + from sympy.stats import cdf + mu, s = self.mean, self.shape + stdNormalcdf = cdf(Normal('x', 0, 1)) + + first_term = stdNormalcdf(sqrt(s/x) * ((x/mu) - S.One)) + second_term = exp(2*s/mu) * stdNormalcdf(-sqrt(s/x)*(x/mu + S.One)) + + return first_term + second_term + + def _characteristic_function(self, t): + mu, s = self.mean, self.shape + return exp((s/mu)*(1 - sqrt(1 - (2*mu**2*I*t)/s))) + + def _moment_generating_function(self, t): + mu, s = self.mean, self.shape + return exp((s/mu)*(1 - sqrt(1 - (2*mu**2*t)/s))) + + +def GaussianInverse(name, mean, shape): + r""" + Create a continuous random variable with an Inverse Gaussian distribution. + Inverse Gaussian distribution is also known as Wald distribution. + + The density of the Inverse Gaussian distribution is given by + + .. math:: + f(x) := \sqrt{\frac{\lambda}{2\pi x^3}} e^{-\frac{\lambda(x-\mu)^2}{2x\mu^2}} + + Parameters + ========== + + mu : Positive number representing the mean + lambda : Positive number representing the shape parameter + + Returns + ======= + + A RandomSymbol. + + Examples + ======== + + >>> from sympy.stats import GaussianInverse, density, cdf, E, std, skewness + >>> from sympy import Symbol, pprint + + >>> mu = Symbol("mu", positive=True) + >>> lamda = Symbol("lambda", positive=True) + >>> z = Symbol("z", positive=True) + >>> X = GaussianInverse("x", mu, lamda) + + >>> D = density(X)(z) + >>> pprint(D, use_unicode=False) + 2 + -lambda*(-mu + z) + ------------------- + 2 + ___ ________ 2*mu *z + \/ 2 *\/ lambda *e + ------------------------------------- + ____ 3/2 + 2*\/ pi *z + + >>> E(X) + mu + + >>> std(X).expand() + mu**(3/2)/sqrt(lambda) + + >>> skewness(X).expand() + 3*sqrt(mu)/sqrt(lambda) + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Inverse_Gaussian_distribution + .. [2] http://mathworld.wolfram.com/InverseGaussianDistribution.html + + """ + + return rv(name, GaussianInverseDistribution, (mean, shape)) + +Wald = GaussianInverse + #------------------------------------------------------------------------------- # Pareto distribution ----------------------------------------------------------

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 32566f4c34f9..802fca1881d9 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1387,6 +1387,10 @@ def test_sympy__stats__crv_types__NormalDistribution(): from sympy.stats.crv_types import NormalDistribution assert _test_args(NormalDistribution(0, 1)) +def test_sympy__stats__crv_types__GaussianInverseDistribution(): + from sympy.stats.crv_types import GaussianInverseDistribution + assert _test_args(GaussianInverseDistribution(1, 1)) + def test_sympy__stats__crv_types__ParetoDistribution(): from sympy.stats.crv_types import ParetoDistribution diff --git a/sympy/stats/tests/test_continuous_rv.py b/sympy/stats/tests/test_continuous_rv.py index c39eb9fe35ec..092d3966ee55 100644 --- a/sympy/stats/tests/test_continuous_rv.py +++ b/sympy/stats/tests/test_continuous_rv.py @@ -16,10 +16,10 @@ ChiNoncentral, Dagum, Erlang, Exponential, FDistribution, FisherZ, Frechet, Gamma, GammaInverse, Gompertz, Gumbel, Kumaraswamy, Laplace, Logistic, - LogNormal, Maxwell, Nakagami, Normal, Pareto, + LogNormal, Maxwell, Nakagami, Normal, GaussianInverse, Pareto, QuadraticU, RaisedCosine, Rayleigh, ShiftedGompertz, StudentT, Trapezoidal, Triangular, Uniform, UniformSum, - VonMises, Weibull, WignerSemicircle, correlation, + VonMises, Weibull, WignerSemicircle, Wald, correlation, moment, cmoment, smoment, quantile) from sympy.stats.crv_types import NormalDistribution from sympy.stats.joint_rv import JointPSpace @@ -158,6 +158,12 @@ def test_characteristic_function(): assert cf(0) == 1 assert cf(1).expand() == S(25)/26 + 5*I/26 + X = GaussianInverse('x', 1, 1) + cf = characteristic_function(X) + assert cf(0) == 1 + assert cf(1) == exp(1 - sqrt(1 - 2*I)) + + def test_moment_generating_function(): t = symbols('t', positive=True) @@ -710,6 +716,40 @@ def test_nakagami(): (lowergamma(mu, mu*x**2/omega)/gamma(mu), x > 0), (0, True)) +def test_gaussian_inverse(): + # test for symbolic parameters + a, b = symbols('a b') + assert GaussianInverse('x', a, b) + + # Inverse Gaussian distribution is also known as Wald distribution + # `GaussianInverse` can also be referred by the name `Wald` + a, b, z = symbols('a b z') + X = Wald('x', a, b) + assert density(X)(z) == sqrt(2)*sqrt(b/z**3)*exp(-b*(-a + z)**2/(2*a**2*z))/(2*sqrt(pi)) + + a, b = symbols('a b', positive=True) + z = Symbol('z', positive=True) + + X = GaussianInverse('x', a, b) + assert density(X)(z) == sqrt(2)*sqrt(b)*sqrt(z**(-3))*exp(-b*(-a + z)**2/(2*a**2*z))/(2*sqrt(pi)) + assert E(X) == a + assert variance(X).expand() == a**3/b + assert cdf(X)(z) == (S.Half - erf(sqrt(2)*sqrt(b)*(1 + z/a)/(2*sqrt(z)))/2)*exp(2*b/a) +\ + erf(sqrt(2)*sqrt(b)*(-1 + z/a)/(2*sqrt(z)))/2 + S.Half + + a = symbols('a', nonpositive=True) + raises(ValueError, lambda: GaussianInverse('x', a, b)) + + a = symbols('a', positive=True) + b = symbols('b', nonpositive=True) + raises(ValueError, lambda: GaussianInverse('x', a, b)) + +def test_sampling_gaussian_inverse(): + scipy = import_module('scipy') + if not scipy: + skip('Scipy not installed. Abort tests for sampling of Gaussian inverse.') + X = GaussianInverse("x", 1, 1) + assert sample(X) in X.pspace.domain.set def test_pareto(): xm, beta = symbols('xm beta', positive=True)

[ { "components": [ { "doc": "", "lines": [ 2340, 2381 ], "name": "GaussianInverseDistribution", "signature": "class GaussianInverseDistribution(SingleContinuousDistribution):", "type": "class" }, { "doc": "", "l...

[ "test_sympy__stats__crv_types__GaussianInverseDistribution", "test_single_normal", "test_conditional_1d", "test_ContinuousDomain", "test_symbolic", "test_cdf", "test_characteristic_function", "test_moment_generating_function", "test_sample_continuous", "test_ContinuousRV", "test_arcsin", "test...

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [GSoC] Added Inverse Normal distribution  #### References to other Issues or PRs  #### Brief description of what is fixed or changed Univariate Inverse Normal distribution has been added to sympy/stats/crv_types. Corresponding tests have to be added. #### Other comments #### Release Notes   - stats - Addition of Inverse Normal distribution to `sympy/stats/crv_types.py`  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/crv_types.py] (definition of GaussianInverseDistribution:) class GaussianInverseDistribution(SingleContinuousDistribution): (definition of GaussianInverseDistribution.set:) def set(self): (definition of GaussianInverseDistribution.check:) def check(mean, shape): (definition of GaussianInverseDistribution.pdf:) def pdf(self, x): (definition of GaussianInverseDistribution.sample:) def sample(self): (definition of GaussianInverseDistribution._cdf:) def _cdf(self, x): (definition of GaussianInverseDistribution._characteristic_function:) def _characteristic_function(self, t): (definition of GaussianInverseDistribution._moment_generating_function:) def _moment_generating_function(self, t): (definition of GaussianInverse:) def GaussianInverse(name, mean, shape): """Create a continuous random variable with an Inverse Gaussian distribution. Inverse Gaussian distribution is also known as Wald distribution. The density of the Inverse Gaussian distribution is given by .. math:: f(x) := \sqrt{\frac{\lambda}{2\pi x^3}} e^{-\frac{\lambda(x-\mu)^2}{2x\mu^2}} Parameters ========== mu : Positive number representing the mean lambda : Positive number representing the shape parameter Returns ======= A RandomSymbol. Examples ======== >>> from sympy.stats import GaussianInverse, density, cdf, E, std, skewness >>> from sympy import Symbol, pprint >>> mu = Symbol("mu", positive=True) >>> lamda = Symbol("lambda", positive=True) >>> z = Symbol("z", positive=True) >>> X = GaussianInverse("x", mu, lamda) >>> D = density(X)(z) >>> pprint(D, use_unicode=False) 2 -lambda*(-mu + z) ------------------- 2 ___ ________ 2*mu *z \/ 2 *\/ lambda *e ------------------------------------- ____ 3/2 2*\/ pi *z >>> E(X) mu >>> std(X).expand() mu**(3/2)/sqrt(lambda) >>> skewness(X).expand() 3*sqrt(mu)/sqrt(lambda) References ========== .. [1] https://en.wikipedia.org/wiki/Inverse_Gaussian_distribution .. [2] http://mathworld.wolfram.com/InverseGaussianDistribution.html""" [end of new definitions in sympy/stats/crv_types.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-16808

16,808

sympy/sympy

1.5

0b090278fd9bd2f9f6f02268b0d0ccf968a9db7b

2019-05-11T10:53:55Z

diff --git a/sympy/stats/joint_rv.py b/sympy/stats/joint_rv.py index 30cddf1e2ced..9a34cd4054b8 100644 --- a/sympy/stats/joint_rv.py +++ b/sympy/stats/joint_rv.py @@ -101,6 +101,7 @@ def marginal_distribution(self, *indices): if self.distribution.is_Continuous: f = Lambda(sym, integrate(self.distribution(*all_syms), *limits)) elif self.distribution.is_Discrete: + limits = [(limit[0], limit[1].inf, limit[1].sup) for limit in limits] f = Lambda(sym, summation(self.distribution(*all_syms), *limits)) return f.xreplace(replace_dict) diff --git a/sympy/stats/joint_rv_types.py b/sympy/stats/joint_rv_types.py index b973729593e1..5f3ecbdc9894 100644 --- a/sympy/stats/joint_rv_types.py +++ b/sympy/stats/joint_rv_types.py @@ -1,5 +1,5 @@ from sympy import (sympify, S, pi, sqrt, exp, Lambda, Indexed, Gt, - IndexedBase) + IndexedBase, besselk, gamma, Interval, Range, factorial, Mul, Integer) from sympy.matrices import ImmutableMatrix from sympy.matrices.expressions.determinant import det from sympy.stats.joint_rv import (JointDistribution, JointPSpace, @@ -124,7 +124,6 @@ def check(self, mu, sigma): "The covariance matrix must be positive definite. ") def pdf(self, *args): - from sympy.functions.special.bessel import besselk mu, sigma = self.mu, self.sigma mu_T = mu.transpose() k = S(len(mu)) @@ -159,7 +158,6 @@ def check(self, mu, sigma, v): "The shape matrix must be positive definite. ") def pdf(self, *args): - from sympy.functions.special.gamma_functions import gamma mu, sigma = self.mu, self.shape_mat v = S(self.dof) k = S(len(mu)) @@ -205,11 +203,9 @@ def check(self, mu, lamda, alpha, beta): @property def set(self): - from sympy.sets.sets import Interval return S.Reals*Interval(0, S.Infinity) def pdf(self, x, tau): - from sympy.functions.special.gamma_functions import gamma beta, alpha, lamda = self.beta, self.alpha, self.lamda mu = self.mu @@ -218,7 +214,6 @@ def pdf(self, x, tau): exp(-1*(lamda*tau*(x - mu)**2)/S(2)) def marginal_distribution(self, indices, *sym): - from sympy.functions.special.gamma_functions import gamma if len(indices) == 2: return self.pdf(*sym) if indices[0] == 0: @@ -253,3 +248,138 @@ def NormalGamma(syms, mu, lamda, alpha, beta): A random symbol """ return multivariate_rv(NormalGammaDistribution, syms, mu, lamda, alpha, beta) + +#------------------------------------------------------------------------------- +# Multinomial distribution --------------------------------------------------------- + +class MultinomialDistribution(JointDistribution): + + _argnames = ['n', 'p'] + is_Continuous=False + is_Discrete = True + + def check(self, n, p): + _value_check(((n > 0) != False) and isinstance(n, Integer), + "number of trials must be a positve integer") + for p_k in p: + _value_check((p_k >= 0) != False, + "probability must be at least a positive symbol.") + + @property + def set(self): + return Range(0, self.n)**len(self.p) + + def pdf(self, *x): + n, p = self.n, self.p + term_1 = factorial(n)/Mul.fromiter([factorial(x_k) for x_k in x]) + term_2 = Mul.fromiter([p_k**x_k for p_k, x_k in zip(p, x)]) + return term_1*term_2 + +def Multinomial(syms, n, *p): + """ + Creates a discrete random variable with Multinomial Distribution. + + The density of the said distribution can be found at [1]. + + Parameters + ========== + n: postive integer of class Integer, + number of trials + p: event probabilites, >= 0 and <= 1 + + Returns + ======= + A RandomSymbol. + + Examples + ======== + >>> from sympy.stats import density + >>> from sympy.stats.joint_rv import marginal_distribution + >>> from sympy.stats.joint_rv_types import Multinomial + >>> from sympy import Symbol + >>> from sympy import symbols + >>> x1, x2, x3 = symbols('x1, x2, x3', nonnegative=True, integer=True) + >>> p1, p2, p3 = symbols('p1, p2, p3', positive=True) + >>> M = Multinomial('M', 3, p1, p2, p3) + >>> density(M)(x1, x2, x3) + 6*p1**x1*p2**x2*p3**x3/(factorial(x1)*factorial(x2)*factorial(x3)) + >>> marginal_distribution(M, M[0])(x1).subs(x1, 1) + 3*p1*p2**2*p3**2/2 + 3*p1*p2**2*p3 + 3*p1*p2**2 + 3*p1*p2*p3**2 + + 6*p1*p2*p3 + 6*p1*p2 + 3*p1*p3**2 + 6*p1*p3 + 6*p1 + + References + ========== + .. [1] https://en.wikipedia.org/wiki/Multinomial_distribution + .. [2] http://mathworld.wolfram.com/MultinomialDistribution.html + """ + if not isinstance(p[0], list): + p = (list(p), ) + return multivariate_rv(MultinomialDistribution, syms, n, p[0]) + +#------------------------------------------------------------------------------- +# Negative Multinomial Distribution --------------------------------------------------------- + +class NegativeMultinomialDistribution(JointDistribution): + + _argnames = ['k0', 'p'] + is_Continuous=False + is_Discrete = True + + def check(self, k0, p): + _value_check(((k0 > 0) != False) and isinstance(k0, Integer), + "number of failures must be a positve integer") + for p_k in p: + _value_check((p_k >= 0) != False, + "probability must be at least a positive symbol.") + + @property + def set(self): + return S.Naturals0**len(self.p) + + def pdf(self, *k): + k0, p = self.k0, self.p + term_1 = (gamma(k0 + sum(k))*(1 - sum(p))**k0)/gamma(k0) + term_2 = Mul.fromiter([pi**ki/factorial(ki) for pi, ki in zip(p, k)]) + return term_1*term_2 + +def NegativeMultinomial(syms, k0, *p): + """ + Creates a discrete random variable with Negative Multinomial Distribution. + + The density of the said distribution can be found at [1]. + + Parameters + ========== + k0: postive integer of class Integer, + number of failures before the experiment is stopped + p: event probabilites, >= 0 and <= 1 + + Returns + ======= + A RandomSymbol. + + Examples + ======== + >>> from sympy.stats import density + >>> from sympy.stats.joint_rv import marginal_distribution + >>> from sympy.stats.joint_rv_types import NegativeMultinomial + >>> from sympy import symbols + >>> x1, x2, x3 = symbols('x1, x2, x3', nonnegative=True, integer=True) + >>> p1, p2, p3 = symbols('p1, p2, p3', positive=True) + >>> N = NegativeMultinomial('M', 3, p1, p2, p3) + >>> N_c = NegativeMultinomial('M', 3, 0.1, 0.1, 0.1) + >>> density(N)(x1, x2, x3) + p1**x1*p2**x2*p3**x3*(-p1 - p2 - p3 + 1)**3*gamma(x1 + x2 + + x3 + 3)/(2*factorial(x1)*factorial(x2)*factorial(x3)) + >>> marginal_distribution(N_c, N_c[0])(1).evalf().round(2) + 0.25 + + + References + ========== + .. [1] https://en.wikipedia.org/wiki/Negative_multinomial_distribution + .. [2] http://mathworld.wolfram.com/NegativeBinomialDistribution.html + """ + if not isinstance(p[0], list): + p = (list(p), ) + return multivariate_rv(NegativeMultinomialDistribution, syms, k0, p[0])

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 7d8ea35b66cf..b86a8d3dd501 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1496,6 +1496,13 @@ def test_sympy__stats__joint_rv_types__NormalGammaDistribution(): from sympy.stats.joint_rv_types import NormalGammaDistribution assert _test_args(NormalGammaDistribution(1, 2, 3, 4)) +def test_sympy__stats__joint_rv_types__MultinomialDistribution(): + from sympy.stats.joint_rv_types import MultinomialDistribution + assert _test_args(MultinomialDistribution(5, [0.5, 0.1, 0.3])) + +def test_sympy__stats__joint_rv_types__NegativeMultinomialDistribution(): + from sympy.stats.joint_rv_types import NegativeMultinomialDistribution + assert _test_args(NegativeMultinomialDistribution(5, [0.5, 0.1, 0.3])) def test_sympy__core__symbol__Dummy(): from sympy.core.symbol import Dummy diff --git a/sympy/stats/tests/test_joint_rv.py b/sympy/stats/tests/test_joint_rv.py index ddb159a5f321..a9ae6e2c7b4b 100644 --- a/sympy/stats/tests/test_joint_rv.py +++ b/sympy/stats/tests/test_joint_rv.py @@ -1,4 +1,5 @@ -from sympy import symbols, pi, oo, S, exp, sqrt, besselk, Indexed +from sympy import (symbols, pi, oo, S, exp, sqrt, besselk, Indexed, factorial, + simplify, gamma) from sympy.stats import density from sympy.stats.joint_rv import marginal_distribution from sympy.stats.joint_rv_types import JointRV @@ -53,6 +54,36 @@ def test_NormalGamma(): 3*sqrt(10)*gamma(S(7)/4)/(10*sqrt(pi)*gamma(S(5)/4)) assert marginal_distribution(ng, y)(1) == exp(-S(1)/4)/128 +def test_Multinomial(): + from sympy.stats.joint_rv_types import Multinomial + n, x1, x2, x3, x4 = symbols('n, x1, x2, x3, x4', nonnegative=True, integer=True) + p1, p2, p3, p4 = symbols('p1, p2, p3, p4', positive=True) + p1_f = symbols('p1_f', negative=True) + M = Multinomial('M', 3, [p1, p2, p3, p4]) + M_c = Multinomial('C', 3, 0.5, 0.4, 0.3, 0.2) + f = factorial + assert simplify(density(M)(x1, x2, x3, x4) - + S(6)*p1**x1*p2**x2*p3**x3*p4**x4/(f(x1)*f(x2)*f(x3)*f(x4))) == S(0) + assert marginal_distribution(M_c, M_c[0])(1).round(2) == 7.29 + raises(ValueError, lambda: Multinomial('b1', 5, [p1, p2, p3, p1_f])) + raises(ValueError, lambda: Multinomial('b2', n, [p1, p2, p3, p4])) + +def test_NegativeMultinomial(): + from sympy.stats.joint_rv_types import NegativeMultinomial + k0, x1, x2, x3, x4 = symbols('k0, x1, x2, x3, x4', nonnegative=True, integer=True) + p1, p2, p3, p4 = symbols('p1, p2, p3, p4', positive=True) + p1_f = symbols('p1_f', negative=True) + N = NegativeMultinomial('N', 4, [p1, p2, p3, p4]) + N_c = NegativeMultinomial('C', 4, 0.1, 0.2, 0.3) + g = gamma + f = factorial + assert simplify(density(N)(x1, x2, x3, x4) - + p1**x1*p2**x2*p3**x3*p4**x4*(-p1 - p2 - p3 - p4 + 1)**4*g(x1 + x2 + + x3 + x4 + 4)/(6*f(x1)*f(x2)*f(x3)*f(x4))) == S(0) + assert marginal_distribution(N_c, N_c[0])(1).evalf().round(2) == 0.33 + raises(ValueError, lambda: NegativeMultinomial('b1', 5, [p1, p2, p3, p1_f])) + raises(ValueError, lambda: NegativeMultinomial('b2', k0, [p1, p2, p3, p4])) + def test_JointPSpace_margial_distribution(): from sympy.stats.joint_rv_types import MultivariateT from sympy import polar_lift

[ { "components": [ { "doc": "", "lines": [ 255, 276 ], "name": "MultinomialDistribution", "signature": "class MultinomialDistribution(JointDistribution):", "type": "class" }, { "doc": "", "lines": [ 26...

[ "test_sympy__stats__joint_rv_types__MultinomialDistribution", "test_sympy__stats__joint_rv_types__NegativeMultinomialDistribution", "test_Multinomial", "test_NegativeMultinomial" ]

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added Multinomial, NegativeMultinomial Distribution  #### References to other Issues or PRs  Extends https://github.com/sympy/sympy/pull/16576/ Don't close any of the two PRs. #### Brief description of what is fixed or changed Multinomial Distribution has been added to sympy.stats.joint_rv_types. There are import issues remaining to be resolved. #### Other comments N/A #### Release Notes   * stats * Addition of Multinomial Distribution to `sympy.stats.joint_rv_types`  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/joint_rv_types.py] (definition of MultinomialDistribution:) class MultinomialDistribution(JointDistribution): (definition of MultinomialDistribution.check:) def check(self, n, p): (definition of MultinomialDistribution.set:) def set(self): (definition of MultinomialDistribution.pdf:) def pdf(self, *x): (definition of Multinomial:) def Multinomial(syms, n, *p): """Creates a discrete random variable with Multinomial Distribution. The density of the said distribution can be found at [1]. Parameters ========== n: postive integer of class Integer, number of trials p: event probabilites, >= 0 and <= 1 Returns ======= A RandomSymbol. Examples ======== >>> from sympy.stats import density >>> from sympy.stats.joint_rv import marginal_distribution >>> from sympy.stats.joint_rv_types import Multinomial >>> from sympy import Symbol >>> from sympy import symbols >>> x1, x2, x3 = symbols('x1, x2, x3', nonnegative=True, integer=True) >>> p1, p2, p3 = symbols('p1, p2, p3', positive=True) >>> M = Multinomial('M', 3, p1, p2, p3) >>> density(M)(x1, x2, x3) 6*p1**x1*p2**x2*p3**x3/(factorial(x1)*factorial(x2)*factorial(x3)) >>> marginal_distribution(M, M[0])(x1).subs(x1, 1) 3*p1*p2**2*p3**2/2 + 3*p1*p2**2*p3 + 3*p1*p2**2 + 3*p1*p2*p3**2 + 6*p1*p2*p3 + 6*p1*p2 + 3*p1*p3**2 + 6*p1*p3 + 6*p1 References ========== .. [1] https://en.wikipedia.org/wiki/Multinomial_distribution .. [2] http://mathworld.wolfram.com/MultinomialDistribution.html""" (definition of NegativeMultinomialDistribution:) class NegativeMultinomialDistribution(JointDistribution): (definition of NegativeMultinomialDistribution.check:) def check(self, k0, p): (definition of NegativeMultinomialDistribution.set:) def set(self): (definition of NegativeMultinomialDistribution.pdf:) def pdf(self, *k): (definition of NegativeMultinomial:) def NegativeMultinomial(syms, k0, *p): """Creates a discrete random variable with Negative Multinomial Distribution. The density of the said distribution can be found at [1]. Parameters ========== k0: postive integer of class Integer, number of failures before the experiment is stopped p: event probabilites, >= 0 and <= 1 Returns ======= A RandomSymbol. Examples ======== >>> from sympy.stats import density >>> from sympy.stats.joint_rv import marginal_distribution >>> from sympy.stats.joint_rv_types import NegativeMultinomial >>> from sympy import symbols >>> x1, x2, x3 = symbols('x1, x2, x3', nonnegative=True, integer=True) >>> p1, p2, p3 = symbols('p1, p2, p3', positive=True) >>> N = NegativeMultinomial('M', 3, p1, p2, p3) >>> N_c = NegativeMultinomial('M', 3, 0.1, 0.1, 0.1) >>> density(N)(x1, x2, x3) p1**x1*p2**x2*p3**x3*(-p1 - p2 - p3 + 1)**3*gamma(x1 + x2 + x3 + 3)/(2*factorial(x1)*factorial(x2)*factorial(x3)) >>> marginal_distribution(N_c, N_c[0])(1).evalf().round(2) 0.25 References ========== .. [1] https://en.wikipedia.org/wiki/Negative_multinomial_distribution .. [2] http://mathworld.wolfram.com/NegativeBinomialDistribution.html""" [end of new definitions in sympy/stats/joint_rv_types.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

joke2k__faker-954

954

joke2k/faker

null

6a26cd10b24e73f1efb2c53033b294a31f831417

2019-05-10T17:57:22Z

diff --git a/faker/providers/automotive/pl_PL/__init__.py b/faker/providers/automotive/pl_PL/__init__.py new file mode 100644 index 0000000000..965a996b9f --- /dev/null +++ b/faker/providers/automotive/pl_PL/__init__.py @@ -0,0 +1,28 @@ +# coding=utf-8 + +from __future__ import unicode_literals +from .. import Provider as AutomotiveProvider + + +class Provider(AutomotiveProvider): + # from + # https://en.wikipedia.org/wiki/Vehicle_registration_plates_of_Poland + license_formats = ( + '?? #####', + '?? ####?', + '?? ###??', + '?? #?###', + '?? #??##', + '??? ?###', + '??? ##??', + '??? #?##', + '??? ##?#', + '??? #??#', + '??? ??##', + '??? #####', + '??? ####?', + '??? ###??', + ) + + def license_plate_regex_formats(self): + return [plate.replace('?', '[A-Z]').replace('#', '[0-9]') for plate in self.license_formats] diff --git a/faker/providers/person/pl_PL/__init__.py b/faker/providers/person/pl_PL/__init__.py index 11c17670b9..49c622df8a 100644 --- a/faker/providers/person/pl_PL/__init__.py +++ b/faker/providers/person/pl_PL/__init__.py @@ -21,6 +21,28 @@ def checksum_identity_card_number(characters): return check_digit +def generate_pesel_checksum_value(pesel_digits): + """ + Calculates and returns a control digit for given PESEL. + """ + checksum_values = [9, 7, 3, 1, 9, 7, 3, 1, 9, 7] + + checksum = sum((int(a) * b for a, b in zip(list(pesel_digits), checksum_values))) + + return checksum % 10 + + +def checksum_pesel_number(pesel_digits): + """ + Calculates and returns True if PESEL is valid. + """ + checksum_values = [1, 3, 7, 9, 1, 3, 7, 9, 1, 3, 1] + + checksum = sum((int(a) * b for a, b in zip(list(pesel_digits), checksum_values))) + + return checksum % 10 == 0 + + class Provider(PersonProvider): formats = ( '{{first_name}} {{last_name}}', @@ -702,3 +724,31 @@ def identity_card_number(self): identity[3] = checksum_identity_card_number(identity) return ''.join(str(character) for character in identity) + + def pesel(self): + """ + Returns 11 characters of Universal Electronic System for Registration of the Population. + Polish: Powszechny Elektroniczny System Ewidencji Ludności. + + PESEL has 11 digits which identifies just one person. + Month: if person was born in 1900-2000, december is 12. If person was born > 2000, we have to add 20 to month, + so december is 32. + Person id: last digit identifies person's sex. Even for females, odd for males. + + https://en.wikipedia.org/wiki/PESEL + """ + + birth = self.generator.date_of_birth() + + year_pesel = str(birth.year)[-2:] + month_pesel = birth.month if birth.year < 2000 else birth.month + 20 + day_pesel = birth.day + person_id = self.random_int(1000, 9999) + + current_pesel = '{year}{month:02d}{day:02d}{person_id:04d}'.format(year=year_pesel, month=month_pesel, + day=day_pesel, + person_id=person_id) + + checksum_value = generate_pesel_checksum_value(current_pesel) + return '{pesel_without_checksum}{checksum_value}'.format(pesel_without_checksum=current_pesel, + checksum_value=checksum_value)

diff --git a/tests/providers/test_automotive.py b/tests/providers/test_automotive.py index 88c57c5cd0..20f3c39ec8 100644 --- a/tests/providers/test_automotive.py +++ b/tests/providers/test_automotive.py @@ -49,3 +49,15 @@ def setUp(self): def test_sv_SE_plate_format(self): plate = self.factory.license_plate() assert re.match(r"[A-Z]{3} \d{2}[\dA-Z]{1}", plate), "%s is not in the correct format." % plate + + +class TestPlPL(unittest.TestCase): + + def setUp(self): + self.factory = Faker('pl_PL') + + def test_pl_PL_plate_format(self): + plate = self.factory.license_plate() + patterns = self.factory.license_plate_regex_formats() + assert re.match(r'{patterns}'.format(patterns='|'.join(patterns)), + plate), '{plate} is not the correct format.'.format(plate=plate) diff --git a/tests/providers/test_person.py b/tests/providers/test_person.py index e7920b242a..c5ec3f8080 100644 --- a/tests/providers/test_person.py +++ b/tests/providers/test_person.py @@ -15,6 +15,7 @@ from faker.providers.person.cs_CZ import Provider as CsCZProvider from faker.providers.person.pl_PL import ( checksum_identity_card_number as pl_checksum_identity_card_number, + checksum_pesel_number as pl_checksum_pesel_number, ) from faker.providers.person.zh_CN import Provider as ZhCNProvider from faker.providers.person.zh_TW import Provider as ZhTWProvider @@ -205,6 +206,14 @@ def test_identity_card_number(self): for _ in range(100): assert re.search(r'^[A-Z]{3}\d{6}$', self.factory.identity_card_number()) + def test_pesel_number_checksum(self): + assert pl_checksum_pesel_number('31090655159') is True + assert pl_checksum_pesel_number('95030853577') is True + assert pl_checksum_pesel_number('05260953442') is True + assert pl_checksum_pesel_number('31090655158') is False + assert pl_checksum_pesel_number('95030853576') is False + assert pl_checksum_pesel_number('05260953441') is False + class TestCsCZ(unittest.TestCase):

[ { "components": [ { "doc": "", "lines": [ 7, 28 ], "name": "Provider", "signature": "class Provider(AutomotiveProvider):", "type": "class" }, { "doc": "", "lines": [ 27, 28 ], ...

[ "tests/providers/test_automotive.py::TestPtBR::test_plate_has_been_generated", "tests/providers/test_automotive.py::TestHuHU::test_hu_HU_plate_format", "tests/providers/test_automotive.py::TestDeDe::test_de_DE_plate_format", "tests/providers/test_automotive.py::TestSvSE::test_sv_SE_plate_format", "tests/pro...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Pldevelop ### What does this changes PESEL and automotive plates for Poland with tests. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/automotive/pl_PL/__init__.py] (definition of Provider:) class Provider(AutomotiveProvider): (definition of Provider.license_plate_regex_formats:) def license_plate_regex_formats(self): [end of new definitions in faker/providers/automotive/pl_PL/__init__.py] [start of new definitions in faker/providers/person/pl_PL/__init__.py] (definition of generate_pesel_checksum_value:) def generate_pesel_checksum_value(pesel_digits): """Calculates and returns a control digit for given PESEL.""" (definition of checksum_pesel_number:) def checksum_pesel_number(pesel_digits): """Calculates and returns True if PESEL is valid.""" (definition of Provider.pesel:) def pesel(self): """Returns 11 characters of Universal Electronic System for Registration of the Population. Polish: Powszechny Elektroniczny System Ewidencji Ludności. PESEL has 11 digits which identifies just one person. Month: if person was born in 1900-2000, december is 12. If person was born > 2000, we have to add 20 to month, so december is 32. Person id: last digit identifies person's sex. Even for females, odd for males. https://en.wikipedia.org/wiki/PESEL""" [end of new definitions in faker/providers/person/pl_PL/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

6edfdbf6ae90b0153309e3bf066aa3b2d16494a7

falconry__falcon-1537

1,537

falconry/falcon

null

e46ca1c1695fb43fedd300c1a771bfff8bf5c34e

2019-05-07T20:14:07Z

diff --git a/docs/_newsfragments/urlencoded-form-media-handler.feature.rst b/docs/_newsfragments/urlencoded-form-media-handler.feature.rst new file mode 100644 index 000000000..9350c3745 --- /dev/null +++ b/docs/_newsfragments/urlencoded-form-media-handler.feature.rst @@ -0,0 +1,2 @@ +``URLEncodedFormHandler`` was added for handling URL-encoded forms (of content +type ``application/x-www-form-urlencoded``) as ``Request.media``. diff --git a/docs/api/media.rst b/docs/api/media.rst index 90c7d3e27..06ec16618 100644 --- a/docs/api/media.rst +++ b/docs/api/media.rst @@ -67,6 +67,7 @@ middleware. Here is an example of how this can be done: def process_request(self, req, resp): resp.content_type = req.accept +.. _custom_media_handlers: Replacing the Default Handlers ------------------------------ @@ -121,6 +122,9 @@ Supported Handler Types .. autoclass:: falcon.media.MessagePackHandler :members: +.. autoclass:: falcon.media.URLEncodedFormHandler + :members: + Custom Handler Type ------------------- @@ -152,6 +156,7 @@ common media types, including the following: falcon.MEDIA_JSON falcon.MEDIA_MSGPACK + falcon.MEDIA_URLENCODED falcon.MEDIA_YAML falcon.MEDIA_XML falcon.MEDIA_HTML diff --git a/docs/user/faq.rst b/docs/user/faq.rst index 01fe0181a..24b02c44d 100644 --- a/docs/user/faq.rst +++ b/docs/user/faq.rst @@ -529,7 +529,34 @@ the form parameters accessible via :attr:`~.Request.params`, api.req_options.auto_parse_form_urlencoded = True -Alternatively, POSTed form parameters may be read directly from +Alternatively, :class:`falcon.media.URLEncodedFormHandler` may be +:ref:`installed <custom_media_handlers>` to handle the +``application/x-www-form-urlencoded`` content type. The form parameters can +then be simply accessed as :attr:`Request.media <falcon.Request.media>`: + +.. code:: python + + import falcon + from falcon import media + + + handlers = media.Handlers({ + falcon.MEDIA_JSON: media.JSONHandler(), + falcon.MEDIA_URLENCODED: media.URLEncodedFormHandler(), + # ... and any other request media handlers you may need + }) + + api = falcon.API() + api.req_options.media_handlers = handlers + +.. note:: + Going forward, the :attr:`~RequestOptions.auto_parse_form_urlencoded` way to + access the submitted form may be deprecated in favor of the media handler in + further development versions of Falcon 3.0 series; + :class:`falcon.media.URLEncodedFormHandler` would then be installed by + default. + +POSTed form parameters may also be read directly from :attr:`~.Request.stream` and parsed via :meth:`falcon.uri.parse_query_string` or `urllib.parse.parse_qs() <https://docs.python.org/3.6/library/urllib.parse.html#urllib.parse.parse_qs>`_. diff --git a/falcon/constants.py b/falcon/constants.py index 1c01939e8..08db4f0e3 100644 --- a/falcon/constants.py +++ b/falcon/constants.py @@ -51,6 +51,8 @@ # but the use of the 'x-' prefix is discouraged by RFC 6838. MEDIA_MSGPACK = 'application/msgpack' +MEDIA_URLENCODED = 'application/x-www-form-urlencoded' + # NOTE(kgriffs): An internet media type for YAML has not been # registered. RoR uses 'application/x-yaml', but since use of # 'x-' is discouraged by RFC 6838, we don't use it in Falcon. diff --git a/falcon/media/__init__.py b/falcon/media/__init__.py index 44cb8d853..c598c8f8b 100644 --- a/falcon/media/__init__.py +++ b/falcon/media/__init__.py @@ -1,5 +1,6 @@ from .base import BaseHandler # NOQA from .json import JSONHandler # NOQA from .msgpack import MessagePackHandler # NOQA +from .urlencoded import URLEncodedFormHandler # NOQA from .handlers import Handlers # NOQA diff --git a/falcon/media/urlencoded.py b/falcon/media/urlencoded.py new file mode 100644 index 000000000..95228fd4b --- /dev/null +++ b/falcon/media/urlencoded.py @@ -0,0 +1,46 @@ +from urllib.parse import urlencode + +from falcon.media.base import BaseHandler +from falcon.util.uri import parse_query_string + + +class URLEncodedFormHandler(BaseHandler): + """ + URL-encoded form data handler. + + This handler parses ``application/x-www-form-urlencoded`` HTML forms to a + ``dict`` in a similar way that URL query parameters are parsed. + + Keyword Arguments: + keep_blank (bool): Whether to keep empty-string values from the form + when deserializing. + csv (bool): Whether to split comma-separated form values into list + when deserializing. + """ + + def __init__(self, keep_blank=True, csv=False): + self.keep_blank = keep_blank + self.csv = csv + + def serialize(self, media, content_type): + # NOTE(vytas): Setting doseq to True to mirror the parse_query_string + # behaviour. + return urlencode(media, doseq=True) + + def deserialize(self, stream, content_type, content_length): + body = stream.read() + + # NOTE(kgriffs): According to http://goo.gl/6rlcux the + # body should be US-ASCII. Enforcing this also helps + # catch malicious input. + body = body.decode('ascii') + + # TODO(vytas): We are not short-circuiting here for performance (as + # empty URL-encoded payload should not be a common case), but to work + # around #1600 + if not body: + return {} + + return parse_query_string(body, + keep_blank=self.keep_blank, + csv=self.csv)

diff --git a/tests/test_media_urlencoded.py b/tests/test_media_urlencoded.py new file mode 100644 index 000000000..6f05c2c7b --- /dev/null +++ b/tests/test_media_urlencoded.py @@ -0,0 +1,70 @@ +import io + +import pytest + +import falcon +from falcon import media +from falcon import testing + + +def test_deserialize_empty_form(): + handler = media.URLEncodedFormHandler() + stream = io.BytesIO(b'') + assert handler.deserialize(stream, falcon.MEDIA_URLENCODED, 0) == {} + + +def test_deserialize_invalid_unicode(): + handler = media.URLEncodedFormHandler() + stream = io.BytesIO('spade=♠'.encode()) + with pytest.raises(UnicodeDecodeError): + print(handler.deserialize(stream, falcon.MEDIA_URLENCODED, 9)) + + +@pytest.mark.parametrize('data,expected', [ + ({'hello': 'world'}, 'hello=world'), + ({'number': [1, 2]}, 'number=1&number=2'), +]) +def test_urlencoded_form_handler_serialize(data, expected): + handler = media.URLEncodedFormHandler() + assert handler.serialize(data, falcon.MEDIA_URLENCODED) == expected + + +class MediaMirror: + + def on_post(self, req, resp): + resp.media = req.media + + +@pytest.fixture +def client(): + handlers = media.Handlers({ + falcon.MEDIA_JSON: media.JSONHandler(), + falcon.MEDIA_URLENCODED: media.URLEncodedFormHandler(), + }) + api = falcon.API() + api.req_options.media_handlers = handlers + api.resp_options.media_handlers = handlers + + api.add_route('/media', MediaMirror()) + + return testing.TestClient(api) + + +def test_empty_form(client): + resp = client.simulate_post( + '/media', + headers={'Content-Type': 'application/x-www-form-urlencoded'}) + assert resp.content == b'' + + +@pytest.mark.parametrize('body,expected', [ + ('a=1&b=&c=3', {'a': '1', 'b': '', 'c': '3'}), + ('param=undefined', {'param': 'undefined'}), + ('color=green&color=black', {'color': ['green', 'black']}), +]) +def test_urlencoded_form(client, body, expected): + resp = client.simulate_post( + '/media', + body=body, + headers={'Content-Type': 'application/x-www-form-urlencoded'}) + assert resp.json == expected

diff --git a/docs/_newsfragments/urlencoded-form-media-handler.feature.rst b/docs/_newsfragments/urlencoded-form-media-handler.feature.rst new file mode 100644 index 000000000..9350c3745 --- /dev/null +++ b/docs/_newsfragments/urlencoded-form-media-handler.feature.rst @@ -0,0 +1,2 @@ +``URLEncodedFormHandler`` was added for handling URL-encoded forms (of content +type ``application/x-www-form-urlencoded``) as ``Request.media``. diff --git a/docs/api/media.rst b/docs/api/media.rst index 90c7d3e27..06ec16618 100644 --- a/docs/api/media.rst +++ b/docs/api/media.rst @@ -67,6 +67,7 @@ middleware. Here is an example of how this can be done: def process_request(self, req, resp): resp.content_type = req.accept +.. _custom_media_handlers: Replacing the Default Handlers ------------------------------ @@ -121,6 +122,9 @@ Supported Handler Types .. autoclass:: falcon.media.MessagePackHandler :members: +.. autoclass:: falcon.media.URLEncodedFormHandler + :members: + Custom Handler Type ------------------- @@ -152,6 +156,7 @@ common media types, including the following: falcon.MEDIA_JSON falcon.MEDIA_MSGPACK + falcon.MEDIA_URLENCODED falcon.MEDIA_YAML falcon.MEDIA_XML falcon.MEDIA_HTML diff --git a/docs/user/faq.rst b/docs/user/faq.rst index 01fe0181a..24b02c44d 100644 --- a/docs/user/faq.rst +++ b/docs/user/faq.rst @@ -529,7 +529,34 @@ the form parameters accessible via :attr:`~.Request.params`, api.req_options.auto_parse_form_urlencoded = True -Alternatively, POSTed form parameters may be read directly from +Alternatively, :class:`falcon.media.URLEncodedFormHandler` may be +:ref:`installed <custom_media_handlers>` to handle the +``application/x-www-form-urlencoded`` content type. The form parameters can +then be simply accessed as :attr:`Request.media <falcon.Request.media>`: + +.. code:: python + + import falcon + from falcon import media + + + handlers = media.Handlers({ + falcon.MEDIA_JSON: media.JSONHandler(), + falcon.MEDIA_URLENCODED: media.URLEncodedFormHandler(), + # ... and any other request media handlers you may need + }) + + api = falcon.API() + api.req_options.media_handlers = handlers + +.. note:: + Going forward, the :attr:`~RequestOptions.auto_parse_form_urlencoded` way to + access the submitted form may be deprecated in favor of the media handler in + further development versions of Falcon 3.0 series; + :class:`falcon.media.URLEncodedFormHandler` would then be installed by + default. + +POSTed form parameters may also be read directly from :attr:`~.Request.stream` and parsed via :meth:`falcon.uri.parse_query_string` or `urllib.parse.parse_qs() <https://docs.python.org/3.6/library/urllib.parse.html#urllib.parse.parse_qs>`_.

[ { "components": [ { "doc": "URL-encoded form data handler.\n\nThis handler parses ``application/x-www-form-urlencoded`` HTML forms to a\n``dict`` in a similar way that URL query parameters are parsed.\n\nKeyword Arguments:\n keep_blank (bool): Whether to keep empty-string values from the form\n...

[ "tests/test_media_urlencoded.py::test_deserialize_empty_form", "tests/test_media_urlencoded.py::test_deserialize_invalid_unicode", "tests/test_media_urlencoded.py::test_urlencoded_form_handler_serialize[data0-hello=world]", "tests/test_media_urlencoded.py::test_urlencoded_form_handler_serialize[data1-number=1...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat(media): add URL-encoded form data handler ~~Just dropping a quick sketch from PyCon sprints, this still a bit rough on edges.~~ We could probably polish documentation & recipes etc, but otherwise this is ready to review as in proposal for inclusion in Falcon 3.0 alpha1. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in falcon/media/urlencoded.py] (definition of URLEncodedFormHandler:) class URLEncodedFormHandler(BaseHandler): """URL-encoded form data handler. This handler parses ``application/x-www-form-urlencoded`` HTML forms to a ``dict`` in a similar way that URL query parameters are parsed. Keyword Arguments: keep_blank (bool): Whether to keep empty-string values from the form when deserializing. csv (bool): Whether to split comma-separated form values into list when deserializing.""" (definition of URLEncodedFormHandler.__init__:) def __init__(self, keep_blank=True, csv=False): (definition of URLEncodedFormHandler.serialize:) def serialize(self, media, content_type): (definition of URLEncodedFormHandler.deserialize:) def deserialize(self, stream, content_type, content_length): [end of new definitions in falcon/media/urlencoded.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

77d5e6394a88ead151c9469494749f95f06b24bf

falconry__falcon-1523

1,523

falconry/falcon

null

0fa55df85849650e6929152887d63f666e4389d4

2019-05-06T18:20:18Z

diff --git a/docs/api/cors.rst b/docs/api/cors.rst new file mode 100644 index 000000000..e67af1650 --- /dev/null +++ b/docs/api/cors.rst @@ -0,0 +1,34 @@ +.. _cors: + +CORS +===== + +`Cross Origin Resource Sharing <https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS>`_ +(CORS) is an additional security check performed by modern +browsers to prevent unauthorized requests between different domains. + +When implementing +a web API, it is common to have to also implement a CORS policy. Therefore, +Falcon provides an easy way to enable a simple CORS policy via a flag passed +to :any:`falcon.API`. + +By default, Falcon's built-in CORS support is disabled, so that any cross-origin +requests will be blocked by the browser. Passing ``cors_enabled=True`` will +cause the framework to include the necessary response headers to allow access +from any origin to any route in the app. Individual responders may override this +behavior by setting the Access-Control-Allow-Origin header explicitly. + +Whether or not you implement a CORS policy, we recommend also putting a robust +AuthN/Z layer in place to authorize individual clients, as needed, to protect +sensitive resources. + +Usage +----- + +.. code:: python + + import falcon + + # Enable a simple CORS policy for all routes + app = falcon.API(cors_enable=True) + diff --git a/docs/api/index.rst b/docs/api/index.rst index 3e6e72d93..52622f88d 100644 --- a/docs/api/index.rst +++ b/docs/api/index.rst @@ -12,6 +12,7 @@ Classes and Functions media redirects middleware + cors hooks routing util diff --git a/falcon/api.py b/falcon/api.py index b6146a282..43f9a7edd 100644 --- a/falcon/api.py +++ b/falcon/api.py @@ -20,6 +20,7 @@ from falcon import api_helpers as helpers, DEFAULT_MEDIA_TYPE, routing from falcon.http_error import HTTPError from falcon.http_status import HTTPStatus +from falcon.middlewares import CORSMiddleware from falcon.request import Request, RequestOptions import falcon.responders from falcon.response import Response, ResponseOptions @@ -136,6 +137,11 @@ def process_response(self, req, resp, resource, req_succeeded) when that same component's ``process_request()`` (or that of a component higher up in the stack) raises an exception. + cors_enable (bool): Set this flag to ``True`` to enable a simple + CORS policy for all routes, including support for preflighted + requests (default ``False``). + (See also: :ref:`CORS <cors>`) + Attributes: req_options: A set of behavioral options related to incoming requests. (See also: :py:class:`~.RequestOptions`) @@ -155,16 +161,34 @@ def process_response(self, req, resp, resource, req_succeeded) '_error_handlers', '_media_type', '_router', '_sinks', '_serialize_error', 'req_options', 'resp_options', '_middleware', '_independent_middleware', '_router_search', - '_static_routes') + '_static_routes', '_cors_enable') def __init__(self, media_type=DEFAULT_MEDIA_TYPE, request_type=Request, response_type=Response, middleware=None, router=None, - independent_middleware=True): + independent_middleware=True, cors_enable=False): self._sinks = [] self._media_type = media_type self._static_routes = [] + if cors_enable: + cm = CORSMiddleware() + + if middleware is None: + middleware = [cm] + else: + try: + # NOTE(kgriffs): Check to see if middleware is an + # iterable, and if so, append the CORSMiddleware + # instance. + iter(middleware) + middleware = list(middleware) + middleware.append(cm) + except TypeError: + # NOTE(kgriffs): Assume the middleware kwarg references + # a single middleware component. + middleware = [middleware, cm] + # set middleware self._middleware = helpers.prepare_middleware( middleware, independent_middleware=independent_middleware) @@ -204,7 +228,6 @@ def __call__(self, env, start_response): # noqa: C901 status and headers on a response. """ - req = self._request_type(env, options=self.req_options) resp = self._response_type(options=self.resp_options) resource = None diff --git a/falcon/middlewares.py b/falcon/middlewares.py new file mode 100644 index 000000000..97fb8dfad --- /dev/null +++ b/falcon/middlewares.py @@ -0,0 +1,29 @@ + +class CORSMiddleware(object): + def process_response(self, req, resp, resource, req_succeeded): + """Implement a simple blanket CORS policy for all routes. + + This middleware provides a simple out-of-the box CORS policy, + including handling of preflighted requests from the browser. + + See also: https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS + """ + + if resp.get_header('Access-Control-Allow-Origin') is None: + resp.set_header('Access-Control-Allow-Origin', '*') + + if (req_succeeded and + req.method == 'OPTIONS' and + req.get_header('Access-Control-Request-Method')): + + # NOTE(kgriffs): This is a CORS preflight request. Patch the + # response accordingly. + + allow = resp.get_header('Allow') + resp.delete_header('Allow') + + allow_headers = req.get_header('Access-Control-Request-Headers', default='*') + + resp.set_header('Access-Control-Allow-Methods', allow) + resp.set_header('Access-Control-Allow-Headers', allow_headers) + resp.set_header('Access-Control-Max-Age', '86400') # 24 hours

diff --git a/tests/test_headers.py b/tests/test_headers.py index 1ee19c8ac..1c2951498 100644 --- a/tests/test_headers.py +++ b/tests/test_headers.py @@ -16,6 +16,12 @@ def client(): return testing.TestClient(app) +@pytest.fixture(scope='function') +def cors_client(): + app = falcon.API(cors_enable=True) + return testing.TestClient(app) + + class XmlResource: def __init__(self, content_type): self.content_type = content_type @@ -233,6 +239,16 @@ def on_get(self, req, resp): resp.expires = self._expires +class CORSHeaderResource: + + def on_get(self, req, resp): + resp.body = "I'm a CORS test response" + + def on_delete(self, req, resp): + resp.set_header('Access-Control-Allow-Origin', 'example.com') + resp.body = "I'm a CORS test response" + + class TestHeaders: def test_content_length(self, client): @@ -691,6 +707,46 @@ def test_content_length_options(self, client): content_length = '0' assert result.headers['Content-Length'] == content_length + def test_disabled_cors_should_not_add_any_extra_headers(self, client): + client.app.add_route('/', CORSHeaderResource()) + result = client.simulate_get() + assert 'Access-Control-Allow-Origin'.lower() not in dict( + result.headers.lower_items()).keys() + + def test_enabled_cors_should_add_extra_headers_on_response(self, cors_client): + cors_client.app.add_route('/', CORSHeaderResource()) + result = cors_client.simulate_get() + assert 'Access-Control-Allow-Origin'.lower() in dict( + result.headers.lower_items()).keys() + + def test_enabled_cors_should_accept_all_origins_requests(self, cors_client): + cors_client.app.add_route('/', CORSHeaderResource()) + + result = cors_client.simulate_get() + assert result.headers['Access-Control-Allow-Origin'] == '*' + + result = cors_client.simulate_delete() + assert result.headers['Access-Control-Allow-Origin'] == 'example.com' + + def test_enabled_cors_handles_preflighting(self, cors_client): + cors_client.app.add_route('/', CORSHeaderResource()) + result = cors_client.simulate_options(headers=( + ('Access-Control-Request-Method', 'GET'), + ('Access-Control-Request-Headers', 'X-PINGOTHER, Content-Type'), + )) + assert result.headers['Access-Control-Allow-Methods'] == 'DELETE, GET' + assert result.headers['Access-Control-Allow-Headers'] == 'X-PINGOTHER, Content-Type' + assert result.headers['Access-Control-Max-Age'] == '86400' # 24 hours in seconds + + def test_enabled_cors_handles_preflighting_no_headers_in_req(self, cors_client): + cors_client.app.add_route('/', CORSHeaderResource()) + result = cors_client.simulate_options(headers=( + ('Access-Control-Request-Method', 'POST'), + )) + assert result.headers['Access-Control-Allow-Methods'] == 'DELETE, GET' + assert result.headers['Access-Control-Allow-Headers'] == '*' + assert result.headers['Access-Control-Max-Age'] == '86400' # 24 hours in seconds + # ---------------------------------------------------------------------- # Helpers # ---------------------------------------------------------------------- diff --git a/tests/test_middleware.py b/tests/test_middleware.py index 4e2d31ffe..008cf2172 100644 --- a/tests/test_middleware.py +++ b/tests/test_middleware.py @@ -137,6 +137,12 @@ def process_response(self): pass +class TestCorsResource: + def on_get(self, req, resp, **kwargs): + resp.status = falcon.HTTP_200 + resp.body = 'Test' + + class TestMiddleware: def setup_method(self, method): # Clear context @@ -804,3 +810,19 @@ def test_process_resource_cached(self, independent_middleware): # NOTE(kgriffs): Short-circuiting does not affect process_response() assert 'end_time' in context + + +class TestCORSMiddlewareWithAnotherMiddleware(TestMiddleware): + + @pytest.mark.parametrize('mw', [ + CaptureResponseMiddleware(), + [CaptureResponseMiddleware()], + (CaptureResponseMiddleware(),), + iter([CaptureResponseMiddleware()]), + ]) + def test_api_initialization_with_cors_enabled_and_middleware_param(self, mw): + app = falcon.API(middleware=mw, cors_enable=True) + app.add_route('/', TestCorsResource()) + client = testing.TestClient(app) + result = client.simulate_get() + assert result.headers['Access-Control-Allow-Origin'] == '*'

diff --git a/docs/api/cors.rst b/docs/api/cors.rst new file mode 100644 index 000000000..e67af1650 --- /dev/null +++ b/docs/api/cors.rst @@ -0,0 +1,34 @@ +.. _cors: + +CORS +===== + +`Cross Origin Resource Sharing <https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS>`_ +(CORS) is an additional security check performed by modern +browsers to prevent unauthorized requests between different domains. + +When implementing +a web API, it is common to have to also implement a CORS policy. Therefore, +Falcon provides an easy way to enable a simple CORS policy via a flag passed +to :any:`falcon.API`. + +By default, Falcon's built-in CORS support is disabled, so that any cross-origin +requests will be blocked by the browser. Passing ``cors_enabled=True`` will +cause the framework to include the necessary response headers to allow access +from any origin to any route in the app. Individual responders may override this +behavior by setting the Access-Control-Allow-Origin header explicitly. + +Whether or not you implement a CORS policy, we recommend also putting a robust +AuthN/Z layer in place to authorize individual clients, as needed, to protect +sensitive resources. + +Usage +----- + +.. code:: python + + import falcon + + # Enable a simple CORS policy for all routes + app = falcon.API(cors_enable=True) + diff --git a/docs/api/index.rst b/docs/api/index.rst index 3e6e72d93..52622f88d 100644 --- a/docs/api/index.rst +++ b/docs/api/index.rst @@ -12,6 +12,7 @@ Classes and Functions media redirects middleware + cors hooks routing util

[ { "components": [ { "doc": "", "lines": [ 2, 29 ], "name": "CORSMiddleware", "signature": "class CORSMiddleware(object):", "type": "class" }, { "doc": "Implement a simple blanket CORS policy for all routes.\n\nThis mid...

[ "tests/test_headers.py::TestHeaders::test_enabled_cors_should_add_extra_headers_on_response", "tests/test_headers.py::TestHeaders::test_enabled_cors_should_accept_all_origins_requests", "tests/test_headers.py::TestHeaders::test_enabled_cors_handles_preflighting", "tests/test_headers.py::TestHeaders::test_enab...

[ "tests/test_headers.py::TestHeaders::test_content_length", "tests/test_headers.py::TestHeaders::test_declared_content_length_on_head", "tests/test_headers.py::TestHeaders::test_declared_content_length_overridden_by_no_body", "tests/test_headers.py::TestHeaders::test_declared_content_length_overriden_by_body_l...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat(API): Adding the flag to handle basic CORS policies in the framework Added a new flag to `falcon.API` class init method in order to turn on/off feature to handle basic CORS policies in the framework. By default, it will come off so all request must meet CORS policies. Addresses: #1194 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in falcon/middlewares.py] (definition of CORSMiddleware:) class CORSMiddleware(object): (definition of CORSMiddleware.process_response:) def process_response(self, req, resp, resource, req_succeeded): """Implement a simple blanket CORS policy for all routes. This middleware provides a simple out-of-the box CORS policy, including handling of preflighted requests from the browser. See also: https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS""" [end of new definitions in falcon/middlewares.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

77d5e6394a88ead151c9469494749f95f06b24bf

scikit-learn__scikit-learn-13806

13,806

scikit-learn/scikit-learn

0.22

9adba491a209b2768274cd7f0499c6e41df8c8fa

2019-05-06T14:14:55Z

diff --git a/doc/whats_new/v0.22.rst b/doc/whats_new/v0.22.rst index 0518d6c9e0de4..44606556e7469 100644 --- a/doc/whats_new/v0.22.rst +++ b/doc/whats_new/v0.22.rst @@ -47,6 +47,12 @@ Changelog of the maximization procedure in :term:`fit`. :pr:`13618` by :user:`Yoshihiro Uchida <c56pony>`. +:mod:`sklearn.pipeline` +....................... + +- |Enhancement| :class:`pipeline.Pipeline` now supports :term:`score_samples` if + the final estimator does. + :pr:`13806` by :user:`Anaël Beaugnon <ab-anssi>`. :mod:`sklearn.svm` .................. diff --git a/sklearn/pipeline.py b/sklearn/pipeline.py index 55df0de701db4..00f087d83f881 100644 --- a/sklearn/pipeline.py +++ b/sklearn/pipeline.py @@ -491,6 +491,25 @@ def decision_function(self, X): Xt = transform.transform(Xt) return self.steps[-1][-1].decision_function(Xt) + @if_delegate_has_method(delegate='_final_estimator') + def score_samples(self, X): + """Apply transforms, and score_samples of the final estimator. + + Parameters + ---------- + X : iterable + Data to predict on. Must fulfill input requirements of first step + of the pipeline. + + Returns + ------- + y_score : ndarray, shape (n_samples,) + """ + Xt = X + for _, _, transformer in self._iter(with_final=False): + Xt = transformer.transform(Xt) + return self.steps[-1][-1].score_samples(Xt) + @if_delegate_has_method(delegate='_final_estimator') def predict_log_proba(self, X): """Apply transforms, and predict_log_proba of the final estimator

diff --git a/sklearn/tests/test_pipeline.py b/sklearn/tests/test_pipeline.py index bae3f0080da35..c8df039e347c6 100644 --- a/sklearn/tests/test_pipeline.py +++ b/sklearn/tests/test_pipeline.py @@ -16,6 +16,7 @@ from sklearn.utils.testing import assert_raises_regex from sklearn.utils.testing import assert_raise_message from sklearn.utils.testing import assert_equal +from sklearn.utils.testing import assert_allclose from sklearn.utils.testing import assert_array_equal from sklearn.utils.testing import assert_array_almost_equal from sklearn.utils.testing import assert_dict_equal @@ -24,6 +25,7 @@ from sklearn.base import clone, BaseEstimator from sklearn.pipeline import Pipeline, FeatureUnion, make_pipeline, make_union from sklearn.svm import SVC +from sklearn.neighbors import LocalOutlierFactor from sklearn.linear_model import LogisticRegression, Lasso from sklearn.linear_model import LinearRegression from sklearn.cluster import KMeans @@ -330,6 +332,36 @@ def test_pipeline_methods_pca_svm(): pipe.score(X, y) +def test_pipeline_score_samples_pca_lof(): + iris = load_iris() + X = iris.data + # Test that the score_samples method is implemented on a pipeline. + # Test that the score_samples method on pipeline yields same results as + # applying transform and score_samples steps separately. + pca = PCA(svd_solver='full', n_components='mle', whiten=True) + lof = LocalOutlierFactor(novelty=True) + pipe = Pipeline([('pca', pca), ('lof', lof)]) + pipe.fit(X) + # Check the shapes + assert pipe.score_samples(X).shape == (X.shape[0],) + # Check the values + lof.fit(pca.fit_transform(X)) + assert_allclose(pipe.score_samples(X), lof.score_samples(pca.transform(X))) + + +def test_score_samples_on_pipeline_without_score_samples(): + X = np.array([[1], [2]]) + y = np.array([1, 2]) + # Test that a pipeline does not have score_samples method when the final + # step of the pipeline does not have score_samples defined. + pipe = make_pipeline(LogisticRegression()) + pipe.fit(X, y) + with pytest.raises(AttributeError, + match="'LogisticRegression' object has no attribute " + "'score_samples'"): + pipe.score_samples(X) + + def test_pipeline_methods_preprocessing_svm(): # Test the various methods of the pipeline (preprocessing + svm). iris = load_iris()

diff --git a/doc/whats_new/v0.22.rst b/doc/whats_new/v0.22.rst index 0518d6c9e0de4..44606556e7469 100644 --- a/doc/whats_new/v0.22.rst +++ b/doc/whats_new/v0.22.rst @@ -47,6 +47,12 @@ Changelog of the maximization procedure in :term:`fit`. :pr:`13618` by :user:`Yoshihiro Uchida <c56pony>`. +:mod:`sklearn.pipeline` +....................... + +- |Enhancement| :class:`pipeline.Pipeline` now supports :term:`score_samples` if + the final estimator does. + :pr:`13806` by :user:`Anaël Beaugnon <ab-anssi>`. :mod:`sklearn.svm` ..................

[ { "components": [ { "doc": "Apply transforms, and score_samples of the final estimator.\n\nParameters\n----------\nX : iterable\n Data to predict on. Must fulfill input requirements of first step\n of the pipeline.\n\nReturns\n-------\ny_score : ndarray, shape (n_samples,)", "lines":...

[ "sklearn/tests/test_pipeline.py::test_pipeline_score_samples_pca_lof", "sklearn/tests/test_pipeline.py::test_score_samples_on_pipeline_without_score_samples" ]

[ "sklearn/tests/test_pipeline.py::test_pipeline_init", "sklearn/tests/test_pipeline.py::test_pipeline_init_tuple", "sklearn/tests/test_pipeline.py::test_pipeline_methods_anova", "sklearn/tests/test_pipeline.py::test_pipeline_fit_params", "sklearn/tests/test_pipeline.py::test_pipeline_sample_weight_supported"...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG] Add function score_samples to Pipeline (fix issue #12542) #### Reference Issues/PRs Fix issue #12542. #### What does this implement/fix? Explain your changes. The pull request adds a function `score_samples` to the `Pipeline`, `GridSearchCV`, and `RandomizedSearchCV`classes (code very similar to the functions `predict_proba`, `decision_function`, `predict_log_proba`). ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/pipeline.py] (definition of Pipeline.score_samples:) def score_samples(self, X): """Apply transforms, and score_samples of the final estimator. Parameters ---------- X : iterable Data to predict on. Must fulfill input requirements of first step of the pipeline. Returns ------- y_score : ndarray, shape (n_samples,)""" [end of new definitions in sklearn/pipeline.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c96e0958da46ebef482a4084cdda3285d5f5ad23

pydata__xarray-2922

2,922

pydata/xarray

0.12

65a5bff79479c4b56d6f733236fe544b7f4120a8

2019-04-26T17:09:02Z

diff --git a/doc/api.rst b/doc/api.rst index 4492d882355..43a9cf53ead 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -165,6 +165,7 @@ Computation Dataset.groupby_bins Dataset.rolling Dataset.rolling_exp + Dataset.weighted Dataset.coarsen Dataset.resample Dataset.diff @@ -340,6 +341,7 @@ Computation DataArray.groupby_bins DataArray.rolling DataArray.rolling_exp + DataArray.weighted DataArray.coarsen DataArray.dt DataArray.resample @@ -577,6 +579,22 @@ Rolling objects core.rolling.DatasetRolling.reduce core.rolling_exp.RollingExp +Weighted objects +================ + +.. autosummary:: + :toctree: generated/ + + core.weighted.DataArrayWeighted + core.weighted.DataArrayWeighted.mean + core.weighted.DataArrayWeighted.sum + core.weighted.DataArrayWeighted.sum_of_weights + core.weighted.DatasetWeighted + core.weighted.DatasetWeighted.mean + core.weighted.DatasetWeighted.sum + core.weighted.DatasetWeighted.sum_of_weights + + Coarsen objects =============== diff --git a/doc/computation.rst b/doc/computation.rst index 1ac30f55ee7..5309f27e9b6 100644 --- a/doc/computation.rst +++ b/doc/computation.rst @@ -1,3 +1,5 @@ +.. currentmodule:: xarray + .. _comput: ########### @@ -241,12 +243,94 @@ You can also use ``construct`` to compute a weighted rolling sum: To avoid this, use ``skipna=False`` as the above example. +.. _comput.weighted: + +Weighted array reductions +========================= + +:py:class:`DataArray` and :py:class:`Dataset` objects include :py:meth:`DataArray.weighted` +and :py:meth:`Dataset.weighted` array reduction methods. They currently +support weighted ``sum`` and weighted ``mean``. + +.. ipython:: python + + coords = dict(month=('month', [1, 2, 3])) + + prec = xr.DataArray([1.1, 1.0, 0.9], dims=('month', ), coords=coords) + weights = xr.DataArray([31, 28, 31], dims=('month', ), coords=coords) + +Create a weighted object: + +.. ipython:: python + + weighted_prec = prec.weighted(weights) + weighted_prec + +Calculate the weighted sum: + +.. ipython:: python + + weighted_prec.sum() + +Calculate the weighted mean: + +.. ipython:: python + + weighted_prec.mean(dim="month") + +The weighted sum corresponds to: + +.. ipython:: python + + weighted_sum = (prec * weights).sum() + weighted_sum + +and the weighted mean to: + +.. ipython:: python + + weighted_mean = weighted_sum / weights.sum() + weighted_mean + +However, the functions also take missing values in the data into account: + +.. ipython:: python + + data = xr.DataArray([np.NaN, 2, 4]) + weights = xr.DataArray([8, 1, 1]) + + data.weighted(weights).mean() + +Using ``(data * weights).sum() / weights.sum()`` would (incorrectly) result +in 0.6. + + +If the weights add up to to 0, ``sum`` returns 0: + +.. ipython:: python + + data = xr.DataArray([1.0, 1.0]) + weights = xr.DataArray([-1.0, 1.0]) + + data.weighted(weights).sum() + +and ``mean`` returns ``NaN``: + +.. ipython:: python + + data.weighted(weights).mean() + + +.. note:: + ``weights`` must be a :py:class:`DataArray` and cannot contain missing values. + Missing values can be replaced manually by ``weights.fillna(0)``. + .. _comput.coarsen: Coarsen large arrays ==================== -``DataArray`` and ``Dataset`` objects include a +:py:class:`DataArray` and :py:class:`Dataset` objects include a :py:meth:`~xarray.DataArray.coarsen` and :py:meth:`~xarray.Dataset.coarsen` methods. This supports the block aggregation along multiple dimensions, diff --git a/doc/examples.rst b/doc/examples.rst index 805395808e0..1d48d29bcc5 100644 --- a/doc/examples.rst +++ b/doc/examples.rst @@ -6,6 +6,7 @@ Examples examples/weather-data examples/monthly-means + examples/area_weighted_temperature examples/multidimensional-coords examples/visualization_gallery examples/ROMS_ocean_model diff --git a/doc/examples/area_weighted_temperature.ipynb b/doc/examples/area_weighted_temperature.ipynb new file mode 100644 index 00000000000..72876e3fc29 --- /dev/null +++ b/doc/examples/area_weighted_temperature.ipynb @@ -0,0 +1,226 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "toc": true + }, + "source": [ + "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n", + "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Compare-weighted-and-unweighted-mean-temperature\" data-toc-modified-id=\"Compare-weighted-and-unweighted-mean-temperature-1\"><span class=\"toc-item-num\">1  </span>Compare weighted and unweighted mean temperature</a></span><ul class=\"toc-item\"><li><ul class=\"toc-item\"><li><span><a href=\"#Data\" data-toc-modified-id=\"Data-1.0.1\"><span class=\"toc-item-num\">1.0.1  </span>Data</a></span></li><li><span><a href=\"#Creating-weights\" data-toc-modified-id=\"Creating-weights-1.0.2\"><span class=\"toc-item-num\">1.0.2  </span>Creating weights</a></span></li><li><span><a href=\"#Weighted-mean\" data-toc-modified-id=\"Weighted-mean-1.0.3\"><span class=\"toc-item-num\">1.0.3  </span>Weighted mean</a></span></li><li><span><a href=\"#Plot:-comparison-with-unweighted-mean\" data-toc-modified-id=\"Plot:-comparison-with-unweighted-mean-1.0.4\"><span class=\"toc-item-num\">1.0.4  </span>Plot: comparison with unweighted mean</a></span></li></ul></li></ul></li></ul></div>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Compare weighted and unweighted mean temperature\n", + "\n", + "\n", + "Author: [Mathias Hauser](https://github.com/mathause/)\n", + "\n", + "\n", + "We use the `air_temperature` example dataset to calculate the area-weighted temperature over its domain. This dataset has a regular latitude/ longitude grid, thus the gridcell area decreases towards the pole. For this grid we can use the cosine of the latitude as proxy for the grid cell area.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:43:57.222351Z", + "start_time": "2020-03-17T14:43:56.147541Z" + } + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import cartopy.crs as ccrs\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "import xarray as xr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data\n", + "\n", + "Load the data, convert to celsius, and resample to daily values" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:43:57.831734Z", + "start_time": "2020-03-17T14:43:57.651845Z" + } + }, + "outputs": [], + "source": [ + "ds = xr.tutorial.load_dataset(\"air_temperature\")\n", + "\n", + "# to celsius\n", + "air = ds.air - 273.15\n", + "\n", + "# resample from 6-hourly to daily values\n", + "air = air.resample(time=\"D\").mean()\n", + "\n", + "air" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the first timestep:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:43:59.887120Z", + "start_time": "2020-03-17T14:43:59.582894Z" + } + }, + "outputs": [], + "source": [ + "projection = ccrs.LambertConformal(central_longitude=-95, central_latitude=45)\n", + "\n", + "f, ax = plt.subplots(subplot_kw=dict(projection=projection))\n", + "\n", + "air.isel(time=0).plot(transform=ccrs.PlateCarree(), cbar_kwargs=dict(shrink=0.7))\n", + "ax.coastlines()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creating weights\n", + "\n", + "For a for a rectangular grid the cosine of the latitude is proportional to the grid cell area." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:44:18.777092Z", + "start_time": "2020-03-17T14:44:18.736587Z" + } + }, + "outputs": [], + "source": [ + "weights = np.cos(np.deg2rad(air.lat))\n", + "weights.name = \"weights\"\n", + "weights" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Weighted mean" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:44:52.607120Z", + "start_time": "2020-03-17T14:44:52.564674Z" + } + }, + "outputs": [], + "source": [ + "air_weighted = air.weighted(weights)\n", + "air_weighted" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:44:54.334279Z", + "start_time": "2020-03-17T14:44:54.280022Z" + } + }, + "outputs": [], + "source": [ + "weighted_mean = air_weighted.mean((\"lon\", \"lat\"))\n", + "weighted_mean" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot: comparison with unweighted mean\n", + "\n", + "Note how the weighted mean temperature is higher than the unweighted." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:45:08.877307Z", + "start_time": "2020-03-17T14:45:08.673383Z" + } + }, + "outputs": [], + "source": [ + "weighted_mean.plot(label=\"weighted\")\n", + "air.mean((\"lon\", \"lat\")).plot(label=\"unweighted\")\n", + "\n", + "plt.legend()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.6" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": true, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/whats-new.rst b/doc/whats-new.rst index aad0e083a8c..5640e872bea 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -25,6 +25,9 @@ Breaking changes New Features ~~~~~~~~~~~~ +- Weighted array reductions are now supported via the new :py:meth:`DataArray.weighted` + and :py:meth:`Dataset.weighted` methods. See :ref:`comput.weighted`. (:issue:`422`, :pull:`2922`). + By `Mathias Hauser <https://github.com/mathause>`_ - Added support for :py:class:`pandas.DatetimeIndex`-style rounding of ``cftime.datetime`` objects directly via a :py:class:`CFTimeIndex` or via the :py:class:`~core.accessor_dt.DatetimeAccessor`. diff --git a/xarray/core/common.py b/xarray/core/common.py index 39aa7982091..a003642076f 100644 --- a/xarray/core/common.py +++ b/xarray/core/common.py @@ -745,6 +745,25 @@ def groupby_bins( }, ) + def weighted(self, weights): + """ + Weighted operations. + + Parameters + ---------- + weights : DataArray + An array of weights associated with the values in this Dataset. + Each value in the data contributes to the reduction operation + according to its associated weight. + + Notes + ----- + ``weights`` must be a DataArray and cannot contain missing values. + Missing values can be replaced by ``weights.fillna(0)``. + """ + + return self._weighted_cls(self, weights) + def rolling( self, dim: Mapping[Hashable, int] = None, diff --git a/xarray/core/dataarray.py b/xarray/core/dataarray.py index b335eeb293b..4b3ecb2744c 100644 --- a/xarray/core/dataarray.py +++ b/xarray/core/dataarray.py @@ -33,6 +33,7 @@ resample, rolling, utils, + weighted, ) from .accessor_dt import CombinedDatetimelikeAccessor from .accessor_str import StringAccessor @@ -258,6 +259,7 @@ class DataArray(AbstractArray, DataWithCoords): _rolling_cls = rolling.DataArrayRolling _coarsen_cls = rolling.DataArrayCoarsen _resample_cls = resample.DataArrayResample + _weighted_cls = weighted.DataArrayWeighted dt = property(CombinedDatetimelikeAccessor) diff --git a/xarray/core/dataset.py b/xarray/core/dataset.py index d5ad1123a54..c10447f6d11 100644 --- a/xarray/core/dataset.py +++ b/xarray/core/dataset.py @@ -46,6 +46,7 @@ resample, rolling, utils, + weighted, ) from .alignment import _broadcast_helper, _get_broadcast_dims_map_common_coords, align from .common import ( @@ -457,6 +458,7 @@ class Dataset(Mapping, ImplementsDatasetReduce, DataWithCoords): _rolling_cls = rolling.DatasetRolling _coarsen_cls = rolling.DatasetCoarsen _resample_cls = resample.DatasetResample + _weighted_cls = weighted.DatasetWeighted def __init__( self, diff --git a/xarray/core/weighted.py b/xarray/core/weighted.py new file mode 100644 index 00000000000..996d2e4c43e --- /dev/null +++ b/xarray/core/weighted.py @@ -0,0 +1,255 @@ +from typing import TYPE_CHECKING, Hashable, Iterable, Optional, Union, overload + +from .computation import dot +from .options import _get_keep_attrs + +if TYPE_CHECKING: + from .dataarray import DataArray, Dataset + +_WEIGHTED_REDUCE_DOCSTRING_TEMPLATE = """ + Reduce this {cls}'s data by a weighted ``{fcn}`` along some dimension(s). + + Parameters + ---------- + dim : str or sequence of str, optional + Dimension(s) over which to apply the weighted ``{fcn}``. + skipna : bool, optional + If True, skip missing values (as marked by NaN). By default, only + skips missing values for float dtypes; other dtypes either do not + have a sentinel missing value (int) or skipna=True has not been + implemented (object, datetime64 or timedelta64). + keep_attrs : bool, optional + If True, the attributes (``attrs``) will be copied from the original + object to the new one. If False (default), the new object will be + returned without attributes. + + Returns + ------- + reduced : {cls} + New {cls} object with weighted ``{fcn}`` applied to its data and + the indicated dimension(s) removed. + + Notes + ----- + Returns {on_zero} if the ``weights`` sum to 0.0 along the reduced + dimension(s). + """ + +_SUM_OF_WEIGHTS_DOCSTRING = """ + Calculate the sum of weights, accounting for missing values in the data + + Parameters + ---------- + dim : str or sequence of str, optional + Dimension(s) over which to sum the weights. + keep_attrs : bool, optional + If True, the attributes (``attrs``) will be copied from the original + object to the new one. If False (default), the new object will be + returned without attributes. + + Returns + ------- + reduced : {cls} + New {cls} object with the sum of the weights over the given dimension. + """ + + +class Weighted: + """An object that implements weighted operations. + + You should create a Weighted object by using the ``DataArray.weighted`` or + ``Dataset.weighted`` methods. + + See Also + -------- + Dataset.weighted + DataArray.weighted + """ + + __slots__ = ("obj", "weights") + + @overload + def __init__(self, obj: "DataArray", weights: "DataArray") -> None: + ... + + @overload # noqa: F811 + def __init__(self, obj: "Dataset", weights: "DataArray") -> None: # noqa: F811 + ... + + def __init__(self, obj, weights): # noqa: F811 + """ + Create a Weighted object + + Parameters + ---------- + obj : DataArray or Dataset + Object over which the weighted reduction operation is applied. + weights : DataArray + An array of weights associated with the values in the obj. + Each value in the obj contributes to the reduction operation + according to its associated weight. + + Notes + ----- + ``weights`` must be a ``DataArray`` and cannot contain missing values. + Missing values can be replaced by ``weights.fillna(0)``. + """ + + from .dataarray import DataArray + + if not isinstance(weights, DataArray): + raise ValueError("`weights` must be a DataArray") + + if weights.isnull().any(): + raise ValueError( + "`weights` cannot contain missing values. " + "Missing values can be replaced by `weights.fillna(0)`." + ) + + self.obj = obj + self.weights = weights + + @staticmethod + def _reduce( + da: "DataArray", + weights: "DataArray", + dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, + skipna: Optional[bool] = None, + ) -> "DataArray": + """reduce using dot; equivalent to (da * weights).sum(dim, skipna) + + for internal use only + """ + + # need to infer dims as we use `dot` + if dim is None: + dim = ... + + # need to mask invalid values in da, as `dot` does not implement skipna + if skipna or (skipna is None and da.dtype.kind in "cfO"): + da = da.fillna(0.0) + + # `dot` does not broadcast arrays, so this avoids creating a large + # DataArray (if `weights` has additional dimensions) + # maybe add fasttrack (`(da * weights).sum(dims=dim, skipna=skipna)`) + return dot(da, weights, dims=dim) + + def _sum_of_weights( + self, da: "DataArray", dim: Optional[Union[Hashable, Iterable[Hashable]]] = None + ) -> "DataArray": + """ Calculate the sum of weights, accounting for missing values """ + + # we need to mask data values that are nan; else the weights are wrong + mask = da.notnull() + + sum_of_weights = self._reduce(mask, self.weights, dim=dim, skipna=False) + + # 0-weights are not valid + valid_weights = sum_of_weights != 0.0 + + return sum_of_weights.where(valid_weights) + + def _weighted_sum( + self, + da: "DataArray", + dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, + skipna: Optional[bool] = None, + ) -> "DataArray": + """Reduce a DataArray by a by a weighted ``sum`` along some dimension(s).""" + + return self._reduce(da, self.weights, dim=dim, skipna=skipna) + + def _weighted_mean( + self, + da: "DataArray", + dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, + skipna: Optional[bool] = None, + ) -> "DataArray": + """Reduce a DataArray by a weighted ``mean`` along some dimension(s).""" + + weighted_sum = self._weighted_sum(da, dim=dim, skipna=skipna) + + sum_of_weights = self._sum_of_weights(da, dim=dim) + + return weighted_sum / sum_of_weights + + def _implementation(self, func, dim, **kwargs): + + raise NotImplementedError("Use `Dataset.weighted` or `DataArray.weighted`") + + def sum_of_weights( + self, + dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, + keep_attrs: Optional[bool] = None, + ) -> Union["DataArray", "Dataset"]: + + return self._implementation( + self._sum_of_weights, dim=dim, keep_attrs=keep_attrs + ) + + def sum( + self, + dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, + skipna: Optional[bool] = None, + keep_attrs: Optional[bool] = None, + ) -> Union["DataArray", "Dataset"]: + + return self._implementation( + self._weighted_sum, dim=dim, skipna=skipna, keep_attrs=keep_attrs + ) + + def mean( + self, + dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, + skipna: Optional[bool] = None, + keep_attrs: Optional[bool] = None, + ) -> Union["DataArray", "Dataset"]: + + return self._implementation( + self._weighted_mean, dim=dim, skipna=skipna, keep_attrs=keep_attrs + ) + + def __repr__(self): + """provide a nice str repr of our Weighted object""" + + klass = self.__class__.__name__ + weight_dims = ", ".join(self.weights.dims) + return f"{klass} with weights along dimensions: {weight_dims}" + + +class DataArrayWeighted(Weighted): + def _implementation(self, func, dim, **kwargs): + + keep_attrs = kwargs.pop("keep_attrs") + if keep_attrs is None: + keep_attrs = _get_keep_attrs(default=False) + + weighted = func(self.obj, dim=dim, **kwargs) + + if keep_attrs: + weighted.attrs = self.obj.attrs + + return weighted + + +class DatasetWeighted(Weighted): + def _implementation(self, func, dim, **kwargs) -> "Dataset": + + return self.obj.map(func, dim=dim, **kwargs) + + +def _inject_docstring(cls, cls_name): + + cls.sum_of_weights.__doc__ = _SUM_OF_WEIGHTS_DOCSTRING.format(cls=cls_name) + + cls.sum.__doc__ = _WEIGHTED_REDUCE_DOCSTRING_TEMPLATE.format( + cls=cls_name, fcn="sum", on_zero="0" + ) + + cls.mean.__doc__ = _WEIGHTED_REDUCE_DOCSTRING_TEMPLATE.format( + cls=cls_name, fcn="mean", on_zero="NaN" + ) + + +_inject_docstring(DataArrayWeighted, "DataArray") +_inject_docstring(DatasetWeighted, "Dataset")

diff --git a/xarray/tests/test_weighted.py b/xarray/tests/test_weighted.py new file mode 100644 index 00000000000..24531215dfb --- /dev/null +++ b/xarray/tests/test_weighted.py @@ -0,0 +1,311 @@ +import numpy as np +import pytest + +import xarray as xr +from xarray import DataArray +from xarray.tests import assert_allclose, assert_equal, raises_regex + + +@pytest.mark.parametrize("as_dataset", (True, False)) +def test_weighted_non_DataArray_weights(as_dataset): + + data = DataArray([1, 2]) + if as_dataset: + data = data.to_dataset(name="data") + + with raises_regex(ValueError, "`weights` must be a DataArray"): + data.weighted([1, 2]) + + +@pytest.mark.parametrize("as_dataset", (True, False)) +@pytest.mark.parametrize("weights", ([np.nan, 2], [np.nan, np.nan])) +def test_weighted_weights_nan_raises(as_dataset, weights): + + data = DataArray([1, 2]) + if as_dataset: + data = data.to_dataset(name="data") + + with pytest.raises(ValueError, match="`weights` cannot contain missing values."): + data.weighted(DataArray(weights)) + + +@pytest.mark.parametrize( + ("weights", "expected"), + (([1, 2], 3), ([2, 0], 2), ([0, 0], np.nan), ([-1, 1], np.nan)), +) +def test_weighted_sum_of_weights_no_nan(weights, expected): + + da = DataArray([1, 2]) + weights = DataArray(weights) + result = da.weighted(weights).sum_of_weights() + + expected = DataArray(expected) + + assert_equal(expected, result) + + +@pytest.mark.parametrize( + ("weights", "expected"), + (([1, 2], 2), ([2, 0], np.nan), ([0, 0], np.nan), ([-1, 1], 1)), +) +def test_weighted_sum_of_weights_nan(weights, expected): + + da = DataArray([np.nan, 2]) + weights = DataArray(weights) + result = da.weighted(weights).sum_of_weights() + + expected = DataArray(expected) + + assert_equal(expected, result) + + +@pytest.mark.parametrize("da", ([1.0, 2], [1, np.nan], [np.nan, np.nan])) +@pytest.mark.parametrize("factor", [0, 1, 3.14]) +@pytest.mark.parametrize("skipna", (True, False)) +def test_weighted_sum_equal_weights(da, factor, skipna): + # if all weights are 'f'; weighted sum is f times the ordinary sum + + da = DataArray(da) + weights = xr.full_like(da, factor) + + expected = da.sum(skipna=skipna) * factor + result = da.weighted(weights).sum(skipna=skipna) + + assert_equal(expected, result) + + +@pytest.mark.parametrize( + ("weights", "expected"), (([1, 2], 5), ([0, 2], 4), ([0, 0], 0)) +) +def test_weighted_sum_no_nan(weights, expected): + + da = DataArray([1, 2]) + + weights = DataArray(weights) + result = da.weighted(weights).sum() + expected = DataArray(expected) + + assert_equal(expected, result) + + +@pytest.mark.parametrize( + ("weights", "expected"), (([1, 2], 4), ([0, 2], 4), ([1, 0], 0), ([0, 0], 0)) +) +@pytest.mark.parametrize("skipna", (True, False)) +def test_weighted_sum_nan(weights, expected, skipna): + + da = DataArray([np.nan, 2]) + + weights = DataArray(weights) + result = da.weighted(weights).sum(skipna=skipna) + + if skipna: + expected = DataArray(expected) + else: + expected = DataArray(np.nan) + + assert_equal(expected, result) + + +@pytest.mark.filterwarnings("ignore:Mean of empty slice") +@pytest.mark.parametrize("da", ([1.0, 2], [1, np.nan], [np.nan, np.nan])) +@pytest.mark.parametrize("skipna", (True, False)) +@pytest.mark.parametrize("factor", [1, 2, 3.14]) +def test_weighted_mean_equal_weights(da, skipna, factor): + # if all weights are equal (!= 0), should yield the same result as mean + + da = DataArray(da) + + # all weights as 1. + weights = xr.full_like(da, factor) + + expected = da.mean(skipna=skipna) + result = da.weighted(weights).mean(skipna=skipna) + + assert_equal(expected, result) + + +@pytest.mark.parametrize( + ("weights", "expected"), (([4, 6], 1.6), ([1, 0], 1.0), ([0, 0], np.nan)) +) +def test_weighted_mean_no_nan(weights, expected): + + da = DataArray([1, 2]) + weights = DataArray(weights) + expected = DataArray(expected) + + result = da.weighted(weights).mean() + + assert_equal(expected, result) + + +@pytest.mark.parametrize( + ("weights", "expected"), (([4, 6], 2.0), ([1, 0], np.nan), ([0, 0], np.nan)) +) +@pytest.mark.parametrize("skipna", (True, False)) +def test_weighted_mean_nan(weights, expected, skipna): + + da = DataArray([np.nan, 2]) + weights = DataArray(weights) + + if skipna: + expected = DataArray(expected) + else: + expected = DataArray(np.nan) + + result = da.weighted(weights).mean(skipna=skipna) + + assert_equal(expected, result) + + +def expected_weighted(da, weights, dim, skipna, operation): + """ + Generate expected result using ``*`` and ``sum``. This is checked against + the result of da.weighted which uses ``dot`` + """ + + weighted_sum = (da * weights).sum(dim=dim, skipna=skipna) + + if operation == "sum": + return weighted_sum + + masked_weights = weights.where(da.notnull()) + sum_of_weights = masked_weights.sum(dim=dim, skipna=True) + valid_weights = sum_of_weights != 0 + sum_of_weights = sum_of_weights.where(valid_weights) + + if operation == "sum_of_weights": + return sum_of_weights + + weighted_mean = weighted_sum / sum_of_weights + + if operation == "mean": + return weighted_mean + + +@pytest.mark.parametrize("dim", ("a", "b", "c", ("a", "b"), ("a", "b", "c"), None)) +@pytest.mark.parametrize("operation", ("sum_of_weights", "sum", "mean")) +@pytest.mark.parametrize("add_nans", (True, False)) +@pytest.mark.parametrize("skipna", (None, True, False)) +@pytest.mark.parametrize("as_dataset", (True, False)) +def test_weighted_operations_3D(dim, operation, add_nans, skipna, as_dataset): + + dims = ("a", "b", "c") + coords = dict(a=[0, 1, 2, 3], b=[0, 1, 2, 3], c=[0, 1, 2, 3]) + + weights = DataArray(np.random.randn(4, 4, 4), dims=dims, coords=coords) + + data = np.random.randn(4, 4, 4) + + # add approximately 25 % NaNs (https://stackoverflow.com/a/32182680/3010700) + if add_nans: + c = int(data.size * 0.25) + data.ravel()[np.random.choice(data.size, c, replace=False)] = np.NaN + + data = DataArray(data, dims=dims, coords=coords) + + if as_dataset: + data = data.to_dataset(name="data") + + if operation == "sum_of_weights": + result = data.weighted(weights).sum_of_weights(dim) + else: + result = getattr(data.weighted(weights), operation)(dim, skipna=skipna) + + expected = expected_weighted(data, weights, dim, skipna, operation) + + assert_allclose(expected, result) + + +@pytest.mark.parametrize("operation", ("sum_of_weights", "sum", "mean")) +@pytest.mark.parametrize("as_dataset", (True, False)) +def test_weighted_operations_nonequal_coords(operation, as_dataset): + + weights = DataArray(np.random.randn(4), dims=("a",), coords=dict(a=[0, 1, 2, 3])) + data = DataArray(np.random.randn(4), dims=("a",), coords=dict(a=[1, 2, 3, 4])) + + if as_dataset: + data = data.to_dataset(name="data") + + expected = expected_weighted( + data, weights, dim="a", skipna=None, operation=operation + ) + result = getattr(data.weighted(weights), operation)(dim="a") + + assert_allclose(expected, result) + + +@pytest.mark.parametrize("dim", ("dim_0", None)) +@pytest.mark.parametrize("shape_data", ((4,), (4, 4), (4, 4, 4))) +@pytest.mark.parametrize("shape_weights", ((4,), (4, 4), (4, 4, 4))) +@pytest.mark.parametrize("operation", ("sum_of_weights", "sum", "mean")) +@pytest.mark.parametrize("add_nans", (True, False)) +@pytest.mark.parametrize("skipna", (None, True, False)) +@pytest.mark.parametrize("as_dataset", (True, False)) +def test_weighted_operations_different_shapes( + dim, shape_data, shape_weights, operation, add_nans, skipna, as_dataset +): + + weights = DataArray(np.random.randn(*shape_weights)) + + data = np.random.randn(*shape_data) + + # add approximately 25 % NaNs + if add_nans: + c = int(data.size * 0.25) + data.ravel()[np.random.choice(data.size, c, replace=False)] = np.NaN + + data = DataArray(data) + + if as_dataset: + data = data.to_dataset(name="data") + + if operation == "sum_of_weights": + result = getattr(data.weighted(weights), operation)(dim) + else: + result = getattr(data.weighted(weights), operation)(dim, skipna=skipna) + + expected = expected_weighted(data, weights, dim, skipna, operation) + + assert_allclose(expected, result) + + +@pytest.mark.parametrize("operation", ("sum_of_weights", "sum", "mean")) +@pytest.mark.parametrize("as_dataset", (True, False)) +@pytest.mark.parametrize("keep_attrs", (True, False, None)) +def test_weighted_operations_keep_attr(operation, as_dataset, keep_attrs): + + weights = DataArray(np.random.randn(2, 2), attrs=dict(attr="weights")) + data = DataArray(np.random.randn(2, 2)) + + if as_dataset: + data = data.to_dataset(name="data") + + data.attrs = dict(attr="weights") + + result = getattr(data.weighted(weights), operation)(keep_attrs=True) + + if operation == "sum_of_weights": + assert weights.attrs == result.attrs + else: + assert data.attrs == result.attrs + + result = getattr(data.weighted(weights), operation)(keep_attrs=None) + assert not result.attrs + + result = getattr(data.weighted(weights), operation)(keep_attrs=False) + assert not result.attrs + + +@pytest.mark.xfail(reason="xr.Dataset.map does not copy attrs of DataArrays GH: 3595") +@pytest.mark.parametrize("operation", ("sum", "mean")) +def test_weighted_operations_keep_attr_da_in_ds(operation): + # GH #3595 + + weights = DataArray(np.random.randn(2, 2)) + data = DataArray(np.random.randn(2, 2), attrs=dict(attr="data")) + data = data.to_dataset(name="a") + + result = getattr(data.weighted(weights), operation)(keep_attrs=True) + + assert data.a.attrs == result.a.attrs

diff --git a/doc/api.rst b/doc/api.rst index 4492d882355..43a9cf53ead 100644 --- a/doc/api.rst +++ b/doc/api.rst @@ -165,6 +165,7 @@ Computation Dataset.groupby_bins Dataset.rolling Dataset.rolling_exp + Dataset.weighted Dataset.coarsen Dataset.resample Dataset.diff @@ -340,6 +341,7 @@ Computation DataArray.groupby_bins DataArray.rolling DataArray.rolling_exp + DataArray.weighted DataArray.coarsen DataArray.dt DataArray.resample @@ -577,6 +579,22 @@ Rolling objects core.rolling.DatasetRolling.reduce core.rolling_exp.RollingExp +Weighted objects +================ + +.. autosummary:: + :toctree: generated/ + + core.weighted.DataArrayWeighted + core.weighted.DataArrayWeighted.mean + core.weighted.DataArrayWeighted.sum + core.weighted.DataArrayWeighted.sum_of_weights + core.weighted.DatasetWeighted + core.weighted.DatasetWeighted.mean + core.weighted.DatasetWeighted.sum + core.weighted.DatasetWeighted.sum_of_weights + + Coarsen objects =============== diff --git a/doc/computation.rst b/doc/computation.rst index 1ac30f55ee7..5309f27e9b6 100644 --- a/doc/computation.rst +++ b/doc/computation.rst @@ -1,3 +1,5 @@ +.. currentmodule:: xarray + .. _comput: ########### @@ -241,12 +243,94 @@ You can also use ``construct`` to compute a weighted rolling sum: To avoid this, use ``skipna=False`` as the above example. +.. _comput.weighted: + +Weighted array reductions +========================= + +:py:class:`DataArray` and :py:class:`Dataset` objects include :py:meth:`DataArray.weighted` +and :py:meth:`Dataset.weighted` array reduction methods. They currently +support weighted ``sum`` and weighted ``mean``. + +.. ipython:: python + + coords = dict(month=('month', [1, 2, 3])) + + prec = xr.DataArray([1.1, 1.0, 0.9], dims=('month', ), coords=coords) + weights = xr.DataArray([31, 28, 31], dims=('month', ), coords=coords) + +Create a weighted object: + +.. ipython:: python + + weighted_prec = prec.weighted(weights) + weighted_prec + +Calculate the weighted sum: + +.. ipython:: python + + weighted_prec.sum() + +Calculate the weighted mean: + +.. ipython:: python + + weighted_prec.mean(dim="month") + +The weighted sum corresponds to: + +.. ipython:: python + + weighted_sum = (prec * weights).sum() + weighted_sum + +and the weighted mean to: + +.. ipython:: python + + weighted_mean = weighted_sum / weights.sum() + weighted_mean + +However, the functions also take missing values in the data into account: + +.. ipython:: python + + data = xr.DataArray([np.NaN, 2, 4]) + weights = xr.DataArray([8, 1, 1]) + + data.weighted(weights).mean() + +Using ``(data * weights).sum() / weights.sum()`` would (incorrectly) result +in 0.6. + + +If the weights add up to to 0, ``sum`` returns 0: + +.. ipython:: python + + data = xr.DataArray([1.0, 1.0]) + weights = xr.DataArray([-1.0, 1.0]) + + data.weighted(weights).sum() + +and ``mean`` returns ``NaN``: + +.. ipython:: python + + data.weighted(weights).mean() + + +.. note:: + ``weights`` must be a :py:class:`DataArray` and cannot contain missing values. + Missing values can be replaced manually by ``weights.fillna(0)``. + .. _comput.coarsen: Coarsen large arrays ==================== -``DataArray`` and ``Dataset`` objects include a +:py:class:`DataArray` and :py:class:`Dataset` objects include a :py:meth:`~xarray.DataArray.coarsen` and :py:meth:`~xarray.Dataset.coarsen` methods. This supports the block aggregation along multiple dimensions, diff --git a/doc/examples.rst b/doc/examples.rst index 805395808e0..1d48d29bcc5 100644 --- a/doc/examples.rst +++ b/doc/examples.rst @@ -6,6 +6,7 @@ Examples examples/weather-data examples/monthly-means + examples/area_weighted_temperature examples/multidimensional-coords examples/visualization_gallery examples/ROMS_ocean_model diff --git a/doc/examples/area_weighted_temperature.ipynb b/doc/examples/area_weighted_temperature.ipynb new file mode 100644 index 00000000000..72876e3fc29 --- /dev/null +++ b/doc/examples/area_weighted_temperature.ipynb @@ -0,0 +1,226 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "toc": true + }, + "source": [ + "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n", + "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Compare-weighted-and-unweighted-mean-temperature\" data-toc-modified-id=\"Compare-weighted-and-unweighted-mean-temperature-1\"><span class=\"toc-item-num\">1  </span>Compare weighted and unweighted mean temperature</a></span><ul class=\"toc-item\"><li><ul class=\"toc-item\"><li><span><a href=\"#Data\" data-toc-modified-id=\"Data-1.0.1\"><span class=\"toc-item-num\">1.0.1  </span>Data</a></span></li><li><span><a href=\"#Creating-weights\" data-toc-modified-id=\"Creating-weights-1.0.2\"><span class=\"toc-item-num\">1.0.2  </span>Creating weights</a></span></li><li><span><a href=\"#Weighted-mean\" data-toc-modified-id=\"Weighted-mean-1.0.3\"><span class=\"toc-item-num\">1.0.3  </span>Weighted mean</a></span></li><li><span><a href=\"#Plot:-comparison-with-unweighted-mean\" data-toc-modified-id=\"Plot:-comparison-with-unweighted-mean-1.0.4\"><span class=\"toc-item-num\">1.0.4  </span>Plot: comparison with unweighted mean</a></span></li></ul></li></ul></li></ul></div>" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Compare weighted and unweighted mean temperature\n", + "\n", + "\n", + "Author: [Mathias Hauser](https://github.com/mathause/)\n", + "\n", + "\n", + "We use the `air_temperature` example dataset to calculate the area-weighted temperature over its domain. This dataset has a regular latitude/ longitude grid, thus the gridcell area decreases towards the pole. For this grid we can use the cosine of the latitude as proxy for the grid cell area.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:43:57.222351Z", + "start_time": "2020-03-17T14:43:56.147541Z" + } + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "import cartopy.crs as ccrs\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "import xarray as xr" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data\n", + "\n", + "Load the data, convert to celsius, and resample to daily values" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:43:57.831734Z", + "start_time": "2020-03-17T14:43:57.651845Z" + } + }, + "outputs": [], + "source": [ + "ds = xr.tutorial.load_dataset(\"air_temperature\")\n", + "\n", + "# to celsius\n", + "air = ds.air - 273.15\n", + "\n", + "# resample from 6-hourly to daily values\n", + "air = air.resample(time=\"D\").mean()\n", + "\n", + "air" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the first timestep:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:43:59.887120Z", + "start_time": "2020-03-17T14:43:59.582894Z" + } + }, + "outputs": [], + "source": [ + "projection = ccrs.LambertConformal(central_longitude=-95, central_latitude=45)\n", + "\n", + "f, ax = plt.subplots(subplot_kw=dict(projection=projection))\n", + "\n", + "air.isel(time=0).plot(transform=ccrs.PlateCarree(), cbar_kwargs=dict(shrink=0.7))\n", + "ax.coastlines()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Creating weights\n", + "\n", + "For a for a rectangular grid the cosine of the latitude is proportional to the grid cell area." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:44:18.777092Z", + "start_time": "2020-03-17T14:44:18.736587Z" + } + }, + "outputs": [], + "source": [ + "weights = np.cos(np.deg2rad(air.lat))\n", + "weights.name = \"weights\"\n", + "weights" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Weighted mean" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:44:52.607120Z", + "start_time": "2020-03-17T14:44:52.564674Z" + } + }, + "outputs": [], + "source": [ + "air_weighted = air.weighted(weights)\n", + "air_weighted" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:44:54.334279Z", + "start_time": "2020-03-17T14:44:54.280022Z" + } + }, + "outputs": [], + "source": [ + "weighted_mean = air_weighted.mean((\"lon\", \"lat\"))\n", + "weighted_mean" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot: comparison with unweighted mean\n", + "\n", + "Note how the weighted mean temperature is higher than the unweighted." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2020-03-17T14:45:08.877307Z", + "start_time": "2020-03-17T14:45:08.673383Z" + } + }, + "outputs": [], + "source": [ + "weighted_mean.plot(label=\"weighted\")\n", + "air.mean((\"lon\", \"lat\")).plot(label=\"unweighted\")\n", + "\n", + "plt.legend()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.6" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": true, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/whats-new.rst b/doc/whats-new.rst index aad0e083a8c..5640e872bea 100644 --- a/doc/whats-new.rst +++ b/doc/whats-new.rst @@ -25,6 +25,9 @@ Breaking changes New Features ~~~~~~~~~~~~ +- Weighted array reductions are now supported via the new :py:meth:`DataArray.weighted` + and :py:meth:`Dataset.weighted` methods. See :ref:`comput.weighted`. (:issue:`422`, :pull:`2922`). + By `Mathias Hauser <https://github.com/mathause>`_ - Added support for :py:class:`pandas.DatetimeIndex`-style rounding of ``cftime.datetime`` objects directly via a :py:class:`CFTimeIndex` or via the :py:class:`~core.accessor_dt.DatetimeAccessor`.

[ { "components": [ { "doc": "Weighted operations.\n\nParameters\n----------\nweights : DataArray\n An array of weights associated with the values in this Dataset.\n Each value in the data contributes to the reduction operation\n according to its associated weight.\n\nNotes\n-----\n``weight...

[ "xarray/tests/test_weighted.py::test_weighted_non_DataArray_weights[True]", "xarray/tests/test_weighted.py::test_weighted_non_DataArray_weights[False]", "xarray/tests/test_weighted.py::test_weighted_weights_nan_raises[weights0-True]", "xarray/tests/test_weighted.py::test_weighted_weights_nan_raises[weights0-F...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feature/weighted - [X] Closes #422 - [X] Tests added - [X] Fully documented, including `whats-new.rst` for all changes and `api.rst` for new API I took a shot at the weighted function - I added a `DataArrayWeighted` class, that currently only implements `mean`. So, there is still quite a bit missing (e.g. `DatasetWeighted`), but let me know what you think. ``` python import numpy as np import xarray as xr da = xr.DataArray([1, 2]) weights = xr.DataArray([4, 6]) da.weighted(weights).mean() # <xarray.DataArray ()> # array(1.6) ``` There are quite a number of difficult edge cases with invalid data, that can be discussed. * I decided to replace all `NaN` in the `weights` with `0`. * if weights sum to `0` it returns `NaN` (and not `inf`) ``` python weights = xr.DataArray([0, 0]) da.weighted(weights).mean() ``` * The following returns `NaN` (could be `1`) ``` python da = xr.DataArray([1, np.nan]) weights = xr.DataArray([1, 0]) da.weighted(weights).mean(skipna=False) ``` It could be good to add all edge-case logic to a separate function but I am not sure if this is possible... ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in xarray/core/common.py] (definition of DataWithCoords.weighted:) def weighted(self, weights): """Weighted operations. Parameters ---------- weights : DataArray An array of weights associated with the values in this Dataset. Each value in the data contributes to the reduction operation according to its associated weight. Notes ----- ``weights`` must be a DataArray and cannot contain missing values. Missing values can be replaced by ``weights.fillna(0)``.""" [end of new definitions in xarray/core/common.py] [start of new definitions in xarray/core/weighted.py] (definition of Weighted:) class Weighted: """An object that implements weighted operations. You should create a Weighted object by using the ``DataArray.weighted`` or ``Dataset.weighted`` methods. See Also -------- Dataset.weighted DataArray.weighted""" (definition of Weighted.__init__:) def __init__(self, obj: "DataArray", weights: "DataArray") -> None: (definition of Weighted.__init__:) def __init__(self, obj: "Dataset", weights: "DataArray") -> None: (definition of Weighted.__init__:) def __init__(self, obj, weights): """Create a Weighted object Parameters ---------- obj : DataArray or Dataset Object over which the weighted reduction operation is applied. weights : DataArray An array of weights associated with the values in the obj. Each value in the obj contributes to the reduction operation according to its associated weight. Notes ----- ``weights`` must be a ``DataArray`` and cannot contain missing values. Missing values can be replaced by ``weights.fillna(0)``.""" (definition of Weighted._reduce:) def _reduce( da: "DataArray", weights: "DataArray", dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, skipna: Optional[bool] = None, ) -> "DataArray": """reduce using dot; equivalent to (da * weights).sum(dim, skipna) for internal use only""" (definition of Weighted._sum_of_weights:) def _sum_of_weights( self, da: "DataArray", dim: Optional[Union[Hashable, Iterable[Hashable]]] = None ) -> "DataArray": """Calculate the sum of weights, accounting for missing values """ (definition of Weighted._weighted_sum:) def _weighted_sum( self, da: "DataArray", dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, skipna: Optional[bool] = None, ) -> "DataArray": """Reduce a DataArray by a by a weighted ``sum`` along some dimension(s).""" (definition of Weighted._weighted_mean:) def _weighted_mean( self, da: "DataArray", dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, skipna: Optional[bool] = None, ) -> "DataArray": """Reduce a DataArray by a weighted ``mean`` along some dimension(s).""" (definition of Weighted._implementation:) def _implementation(self, func, dim, **kwargs): (definition of Weighted.sum_of_weights:) def sum_of_weights( self, dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, keep_attrs: Optional[bool] = None, ) -> Union["DataArray", "Dataset"]: (definition of Weighted.sum:) def sum( self, dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, skipna: Optional[bool] = None, keep_attrs: Optional[bool] = None, ) -> Union["DataArray", "Dataset"]: (definition of Weighted.mean:) def mean( self, dim: Optional[Union[Hashable, Iterable[Hashable]]] = None, skipna: Optional[bool] = None, keep_attrs: Optional[bool] = None, ) -> Union["DataArray", "Dataset"]: (definition of Weighted.__repr__:) def __repr__(self): """provide a nice str repr of our Weighted object""" (definition of DataArrayWeighted:) class DataArrayWeighted(Weighted): (definition of DataArrayWeighted._implementation:) def _implementation(self, func, dim, **kwargs): (definition of DatasetWeighted:) class DatasetWeighted(Weighted): (definition of DatasetWeighted._implementation:) def _implementation(self, func, dim, **kwargs) -> "Dataset": (definition of _inject_docstring:) def _inject_docstring(cls, cls_name): [end of new definitions in xarray/core/weighted.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> add average function It would be nice to be able to do `ds.average()` to compute weighted averages (e.g. for geo data). Of course this would require the axes to be in a predictable order. Or to give a weight per dimension... ---------- Module error checking, etc., this would look something like: ``` python def average(self, dim=None, weights=None): if weights is None: return self.mean(dim) else: return (self * weights).sum(dim) / weights.sum(dim) ``` This is pretty easy to do manually, but I can see the value in having the standard method around, so I'm definitely open to PRs to add this functionality. This is has to be adjusted if there are `NaN` in the array. `weights.sum(dim)` needs to be corrected not to count weights on indices where there is a `NaN` in `self`. Is there a better way to get the correct weights than: ``` total_weights = weights.sum(dim) * self / self ``` It should probably not be used on a Dataset as every DataArray may have its own `NaN` structure. Or the equivalent Dataset method should loop through the DataArrays. Possibly using where, e.g., `weights.where(self.notnull()).sum(dim)`. Thanks - that seems to be the fastest possibility. I wrote the functions for Dataset and DataArray ``` python def average_da(self, dim=None, weights=None): """ weighted average for DataArrays Parameters ---------- dim : str or sequence of str, optional Dimension(s) over which to apply average. weights : DataArray weights to apply. Shape must be broadcastable to shape of self. Returns ------- reduced : DataArray New DataArray with average applied to its data and the indicated dimension(s) removed. """ if weights is None: return self.mean(dim) else: if not isinstance(weights, xray.DataArray): raise ValueError("weights must be a DataArray") # if NaNs are present, we need individual weights if self.notnull().any(): total_weights = weights.where(self.notnull()).sum(dim=dim) else: total_weights = weights.sum(dim) return (self * weights).sum(dim) / total_weights # ----------------------------------------------------------------------------- def average_ds(self, dim=None, weights=None): """ weighted average for Datasets Parameters ---------- dim : str or sequence of str, optional Dimension(s) over which to apply average. weights : DataArray weights to apply. Shape must be broadcastable to shape of data. Returns ------- reduced : Dataset New Dataset with average applied to its data and the indicated dimension(s) removed. """ if weights is None: return self.mean(dim) else: return self.apply(average_da, dim=dim, weights=weights) ``` They can be combined to one function: ``` python def average(data, dim=None, weights=None): """ weighted average for xray objects Parameters ---------- data : Dataset or DataArray the xray object to average over dim : str or sequence of str, optional Dimension(s) over which to apply average. weights : DataArray weights to apply. Shape must be broadcastable to shape of data. Returns ------- reduced : Dataset or DataArray New xray object with average applied to its data and the indicated dimension(s) removed. """ if isinstance(data, xray.Dataset): return average_ds(data, dim, weights) elif isinstance(data, xray.DataArray): return average_da(data, dim, weights) else: raise ValueError("date must be an xray Dataset or DataArray") ``` Or a monkey patch: ``` python xray.DataArray.average = average_da xray.Dataset.average = average_ds ``` @MaximilianR has suggested a `groupby`/`rolling`-like interface to weighted reductions. ``` Python da.weighted(weights=ds.dim).mean() # or maybe da.weighted(time=days_per_month(da.time)).mean() ``` I really like this idea, as does @shoyer. I'm going to close my PR in hopes of this becoming reality. I would suggest not using keyword arguments for `weighted`. Instead, just align based on the labels of the argument like regular xarray operations. So we'd write `da.weighted(days_per_month(da.time)).mean()` Sounds like a clean solution. Then we can defer handling of NaN in the weights to `weighted` (e.g. by a `skipna_weights` argument in `weighted`). Also returning `sum_of_weights` can be a method of the class. We may still end up implementing all required methods separately in `weighted`. For mean we do: ``` (data * weights / sum_of_weights).sum(dim=dim) ``` i.e. we use `sum` and not `mean`. We could rewrite this to: ``` (data * weights / sum_of_weights).mean(dim=dim) * weights.count(dim=dim) ``` However, I think this can not be generalized to a `reduce` function. See e.g. for `std` http://stackoverflow.com/questions/30383270/how-do-i-calculate-the-standard-deviation-between-weighted-measurements Additionally, `weighted` does not make sense for many operations (I would say) e.g.: `min`, `max`, `count`, ... Do we want ``` da.weighted(weight, dim='time').mean() ``` or ``` da.weighted(weight).mean(dim='time') ``` @mathause - I would think you want the latter (`da.weighted(weight).mean(dim='time')`). `weighted` should handle the brodcasting of `weight` such that you could do this: ``` Python >>> da.shape (72, 10, 15) >>> da.dims ('time', 'x', 'y') >>> weights = some_func_of_time(time) >>> da.weighted(weights).mean(dim=('time', 'x')) ... ``` Yes, +1 for `da.weighted(weight).mean(dim='time')`. The `mean` method on `weighted` should have the same arguments as the `mean` method on `DataArray` -- it's just changed due to the context. > We may still end up implementing all required methods separately in weighted. This is a fair point, I haven't looked in to the details of these implementations yet. But I expect there are still at least a few picks of logic that we will be able to share. @mathause can you please comment on the status of this issue? Is there an associated PR somewhere? Thanks! Hi, my research group recently discussed weighted averaging with x-array, and I was wondering if there had been any progress with implementing this? I'd be happy to get involved if help is needed. Thanks! Hi, This would be a really nice feature to have. I'd be happy to help too. Thank you Found this issue due to @rabernats [blogpost](https://medium.com/pangeo/supporting-new-xarray-contributors-6c42b12b0811). This is a much requested feature in our working group, and it would be great to build onto it in xgcm aswell. I would be very keen to help this advance. It would be great to have some progress on this issue! @mathause, @pgierz, @markelg, or @jbusecke if there is anything we can do to help you get started let us know. I have to say that I am still pretty bad at thinking fully object orientented, but is this what we want in general? A subclass `of xr.DataArray` which gets initialized with a weight array and with some logic for nans then 'knows' about the weight count? Where would I find a good analogue for this sort of organization? In the `rolling` class? I like the syntax proposed by @jhamman above, but I am wondering what happens in a slightly modified example: ``` >>> da.shape (72, 10, 15) >>> da.dims ('time', 'x', 'y') >>> weights = some_func_of_x(x) >>> da.weighted(weights).mean(dim=('x', 'y')) ``` I think we should maybe build in a warning that when the `weights` array does not contain both of the average dimensions? It was mentioned that the functions on `...weighted()`, would have to be mostly rewritten since the logic for a weigthed average and std differs. What other functions should be included (if any)? > I think we should maybe build in a warning that when the weights array does not contain both of the average dimensions? hmm.. the intent here would be that the weights are broadcasted against the input array no? Not sure that a warning is required. e.g. @shoyer's comment above: > I would suggest not using keyword arguments for `weighted`. Instead, just align based on the labels of the argument like regular xarray operations. So we'd write `da.weighted(days_per_month(da.time)).mean()` Are we going to require that the argument to `weighted` is a `DataArray` that shares at least one dimension with `da`? Point taken. I am still not thinking general enough :-) > Are we going to require that the argument to weighted is a DataArray that shares at least one dimension with da? This sounds good to me. With regard to the implementation, I thought of orienting myself along the lines of `groupby`, `rolling` or `resample`. Or are there any concerns for this specific method? Maybe a bad question, but is there a good jumping off point to gain some familiarity with the code base? It’s admittedly my first time looking at xarray from the inside... @pgierz take a look at the "good first issue" label: https://github.com/pydata/xarray/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22 @pgierz - Our documentation has a page on [contributing](http://xarray.pydata.org/en/stable/contributing.html) which I encourage you to read through. ~Unfortunately, we don't have any "developer documentation" to explain the actual code base itself. That would be good to add at some point.~ **Edit**: that was wrong. We have a page on [xarray internals](http://xarray.pydata.org/en/stable/internals.html). Once you have your local development environment set up and your fork cloned, the next step is to start exploring the source code and figuring out where changes need to be made. At that point, you can post any questions you have here and we will be happy to give you some guidance. Can the stats functions from https://esmlab.readthedocs.io/en/latest/api.html#statistics-functions be used? > With regard to the implementation, I thought of orienting myself along the lines of groupby, rolling or resample. Or are there any concerns for this specific method? I would do the same i.e. take inspiration from the groupby / rolling / resample modules. -------------------- </issues>

1c198a191127c601d091213c4b3292a8bb3054e1

sympy__sympy-16693

16,693

sympy/sympy

1.5

967df3b9dc4a5b98a019d18883d72ac14a5955d6

2019-04-20T07:41:44Z

diff --git a/sympy/core/basic.py b/sympy/core/basic.py index bac4d403209a..208b1be2b12a 100644 --- a/sympy/core/basic.py +++ b/sympy/core/basic.py @@ -1666,7 +1666,7 @@ def _visit_eval_derivative_array(self, base): # Types are (base: array/matrix, self: scalar) # Base is some kind of array/matrix, # it should have `.applyfunc(lambda x: x.diff(self)` implemented: - return base._eval_derivative(self) + return base._eval_derivative_array(self) def _eval_derivative_n_times(self, s, n): # This is the default evaluator for derivatives (as called by `diff` diff --git a/sympy/core/function.py b/sympy/core/function.py index 7ed066a03cb9..7497d58d6014 100644 --- a/sympy/core/function.py +++ b/sympy/core/function.py @@ -1331,7 +1331,7 @@ def __new__(cls, expr, *variables, **kwargs): if zero: if isinstance(expr, (MatrixCommon, NDimArray)): return expr.zeros(*expr.shape) - else: + elif expr.is_scalar: return S.Zero # make the order of symbols canonical diff --git a/sympy/matrices/expressions/hadamard.py b/sympy/matrices/expressions/hadamard.py index 7cbb317e0735..cc9221739f9e 100644 --- a/sympy/matrices/expressions/hadamard.py +++ b/sympy/matrices/expressions/hadamard.py @@ -85,17 +85,17 @@ def _eval_derivative_matrix_lines(self, x): diagonal = [(0, 2), (3, 4)] diagonal = [e for j, e in enumerate(diagonal) if self.shape[j] != 1] for i in d: - ptr1 = i.first_pointer - ptr2 = i.second_pointer + l1 = i._lines[i._first_line_index] + l2 = i._lines[i._second_line_index] subexpr = ExprBuilder( CodegenArrayDiagonal, [ ExprBuilder( CodegenArrayTensorProduct, [ - ExprBuilder(_make_matrix, [i._lines[0]]), + ExprBuilder(_make_matrix, [l1]), hadam, - ExprBuilder(_make_matrix, [i._lines[1]]), + ExprBuilder(_make_matrix, [l2]), ] ), ] + diagonal, # turn into *diagonal after dropping Python 2.7 @@ -176,19 +176,19 @@ def _eval_derivative_matrix_lines(self, x): lr = self.base._eval_derivative_matrix_lines(x) for i in lr: - ptr1 = i.first_pointer - ptr2 = i.second_pointer diagonal = [(1, 2), (3, 4)] diagonal = [e for j, e in enumerate(diagonal) if self.base.shape[j] != 1] + l1 = i._lines[i._first_line_index] + l2 = i._lines[i._second_line_index] subexpr = ExprBuilder( CodegenArrayDiagonal, [ ExprBuilder( CodegenArrayTensorProduct, [ - ExprBuilder(_make_matrix, [ptr1]), + ExprBuilder(_make_matrix, [l1]), self.exp*hadamard_power(self.base, self.exp-1), - ExprBuilder(_make_matrix, [ptr2]), + ExprBuilder(_make_matrix, [l2]), ] ), ] + diagonal, # turn into *diagonal after dropping Python 2.7 @@ -196,7 +196,9 @@ def _eval_derivative_matrix_lines(self, x): ) i._first_pointer_parent = subexpr.args[0].args[0].args i._first_pointer_index = 0 + i._first_line_index = 0 i._second_pointer_parent = subexpr.args[0].args[2].args - i._second_pointer_index = 2 + i._second_pointer_index = 0 + i._second_line_index = 0 i._lines = [subexpr] return lr diff --git a/sympy/matrices/expressions/matexpr.py b/sympy/matrices/expressions/matexpr.py index 8e4da20e3fa0..0ee72798fe99 100644 --- a/sympy/matrices/expressions/matexpr.py +++ b/sympy/matrices/expressions/matexpr.py @@ -69,6 +69,7 @@ class MatrixExpr(Expr): is_commutative = False is_number = False is_symbol = False + is_scalar = False def __new__(cls, *args, **kwargs): args = map(_sympify, args) @@ -197,7 +198,14 @@ def _eval_adjoint(self): return Adjoint(self) def _eval_derivative(self, x): - return _matrix_derivative(self, x) + # x is a scalar: + return ZeroMatrix(self.shape[0], self.shape[1]) + + def _eval_derivative_array(self, x): + if isinstance(x, MatrixExpr): + return _matrix_derivative(self, x) + else: + return self._eval_derivative(x) def _eval_derivative_n_times(self, x, n): return Basic._eval_derivative_n_times(self, x, n) @@ -1041,8 +1049,10 @@ def __init__(self, lines, higher=S.One): self._lines = [i for i in lines] self._first_pointer_parent = self._lines self._first_pointer_index = 0 + self._first_line_index = 0 self._second_pointer_parent = self._lines self._second_pointer_index = 1 + self._second_line_index = 1 self.higher = higher @property @@ -1074,6 +1084,7 @@ def __repr__(self): def transpose(self): self._first_pointer_parent, self._second_pointer_parent = self._second_pointer_parent, self._first_pointer_parent self._first_pointer_index, self._second_pointer_index = self._second_pointer_index, self._first_pointer_index + self._first_line_index, self._second_line_index = self._second_line_index, self._first_line_index return self @staticmethod diff --git a/sympy/tensor/array/ndim_array.py b/sympy/tensor/array/ndim_array.py index 640587c1e869..4e01c8e3e6a2 100644 --- a/sympy/tensor/array/ndim_array.py +++ b/sympy/tensor/array/ndim_array.py @@ -246,6 +246,9 @@ def _eval_derivative_n_times(self, s, n): return Basic._eval_derivative_n_times(self, s, n) def _eval_derivative(self, arg): + return self.applyfunc(lambda x: x.diff(arg)) + + def _eval_derivative_array(self, arg): from sympy import derive_by_array from sympy import Tuple from sympy.matrices.common import MatrixCommon

diff --git a/sympy/matrices/expressions/tests/test_derivatives.py b/sympy/matrices/expressions/tests/test_derivatives.py index fd7bf3987901..fe0b8e7b96f7 100644 --- a/sympy/matrices/expressions/tests/test_derivatives.py +++ b/sympy/matrices/expressions/tests/test_derivatives.py @@ -10,6 +10,7 @@ from sympy.matrices.expressions import hadamard_power k = symbols("k") +i, j = symbols("i j") X = MatrixSymbol("X", k, k) x = MatrixSymbol("x", k, 1) @@ -41,6 +42,13 @@ def _check_derivative_with_explicit_matrix(expr, x, diffexpr, dim=2): assert expr.diff(x).reshape(*diffexpr.shape).tomatrix() == diffexpr +def test_matrix_derivative_by_scalar(): + assert A.diff(i) == ZeroMatrix(k, k) + assert (A*(X + B)*c).diff(i) == ZeroMatrix(k, 1) + assert x.diff(i) == ZeroMatrix(k, 1) + assert (x.T*y).diff(i) == ZeroMatrix(1, 1) + + def test_matrix_derivative_non_matrix_result(): # This is a 4-dimensional array: assert A.diff(A) == Derivative(A, A) @@ -378,6 +386,9 @@ def test_derivatives_of_hadamard_expressions(): expr = hadamard_power(x, 2) assert expr.diff(x).doit() == 2*DiagonalizeVector(x) + expr = hadamard_power(x.T, 2) + assert expr.diff(x).doit() == 2*DiagonalizeVector(x) + expr = hadamard_power(x, S.Half) assert expr.diff(x) == S.Half*DiagonalizeVector(hadamard_power(x, -S.Half))

[ { "components": [ { "doc": "", "lines": [ 204, 208 ], "name": "MatrixExpr._eval_derivative_array", "signature": "def _eval_derivative_array(self, x):", "type": "function" } ], "file": "sympy/matrices/expressions/matexpr.py" ...

[ "test_matrix_derivative_by_scalar" ]

[ "test_matrix_derivative_non_matrix_result", "test_matrix_derivative_trivial_cases", "test_matrix_derivative_with_inverse", "test_matrix_derivative_vectors_and_scalars", "test_matrix_derivatives_of_traces", "test_derivatives_of_complicated_matrix_expr", "test_mixed_deriv_mixed_expressions", "test_deriv...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> allow matrix expression to be derived by scalar …d derivatives  #### References to other Issues or PRs  #### Brief description of what is fixed or changed #### Other comments #### Release Notes   * matrices * Allow matrix expressions to be derived by a scalar.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/matrices/expressions/matexpr.py] (definition of MatrixExpr._eval_derivative_array:) def _eval_derivative_array(self, x): [end of new definitions in sympy/matrices/expressions/matexpr.py] [start of new definitions in sympy/tensor/array/ndim_array.py] (definition of NDimArray._eval_derivative_array:) def _eval_derivative_array(self, arg): [end of new definitions in sympy/tensor/array/ndim_array.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-16685

16,685

sympy/sympy

1.5

d10b94aa5a5863957c63eef687cee2a9d27bf99a

2019-04-19T10:19:37Z

diff --git a/sympy/matrices/__init__.py b/sympy/matrices/__init__.py index fe3ec2b31615..9eccd3757051 100644 --- a/sympy/matrices/__init__.py +++ b/sympy/matrices/__init__.py @@ -27,4 +27,4 @@ Transpose, ZeroMatrix, OneMatrix, blockcut, block_collapse, matrix_symbols, Adjoint, hadamard_product, HadamardProduct, HadamardPower, Determinant, det, diagonalize_vector, DiagonalizeVector, DiagonalMatrix, DiagonalOf, trace, - DotProduct, kronecker_product, KroneckerProduct) + DotProduct, kronecker_product, KroneckerProduct, OneMatrix) diff --git a/sympy/matrices/expressions/hadamard.py b/sympy/matrices/expressions/hadamard.py index 7ccb98e3206a..55202675d898 100644 --- a/sympy/matrices/expressions/hadamard.py +++ b/sympy/matrices/expressions/hadamard.py @@ -1,8 +1,12 @@ from __future__ import print_function, division from sympy.core import Mul, sympify -from sympy.matrices.expressions.matexpr import MatrixExpr, ShapeError -from sympy.strategies import unpack, flatten, condition, exhaust, do_one +from sympy.matrices.expressions.matexpr import ( + MatrixExpr, ShapeError, Identity, OneMatrix, ZeroMatrix +) +from sympy.strategies import ( + unpack, flatten, condition, exhaust, do_one, rm_id, sort +) def hadamard_product(*matrices): @@ -36,15 +40,23 @@ class HadamardProduct(MatrixExpr): """ Elementwise product of matrix expressions - This is a symbolic object that simply stores its argument without - evaluating it. To actually compute the product, use the function - ``hadamard_product()``. + Examples + ======== + + Hadamard product for matrix symbols: >>> from sympy.matrices import hadamard_product, HadamardProduct, MatrixSymbol >>> A = MatrixSymbol('A', 5, 5) >>> B = MatrixSymbol('B', 5, 5) >>> isinstance(hadamard_product(A, B), HadamardProduct) True + + Notes + ===== + + This is a symbolic object that simply stores its argument without + evaluating it. To actually compute the product, use the function + ``hadamard_product()`` or ``HadamardProduct.doit`` """ is_HadamardProduct = True @@ -53,6 +65,7 @@ def __new__(cls, *args, **kwargs): check = kwargs.get('check', True) if check: validate(*args) + return super(HadamardProduct, cls).__new__(cls, *args) @property @@ -119,11 +132,141 @@ def validate(*args): if A.shape != B.shape: raise ShapeError("Matrices %s and %s are not aligned" % (A, B)) -rules = (unpack, - flatten) -canonicalize = exhaust(condition(lambda x: isinstance(x, HadamardProduct), - do_one(*rules))) +# TODO Implement algorithm for rewriting Hadamard product as diagonal matrix +# if matmul identy matrix is multiplied. +def canonicalize(x): + """Canonicalize the Hadamard product ``x`` with mathematical properties. + + Examples + ======== + + >>> from sympy.matrices.expressions import MatrixSymbol, HadamardProduct + >>> from sympy.matrices.expressions import OneMatrix, ZeroMatrix + >>> from sympy.matrices.expressions.hadamard import canonicalize + + >>> A = MatrixSymbol('A', 2, 2) + >>> B = MatrixSymbol('B', 2, 2) + >>> C = MatrixSymbol('C', 2, 2) + + Hadamard product associativity: + + >>> X = HadamardProduct(A, HadamardProduct(B, C)) + >>> X + A.*(B.*C) + >>> canonicalize(X) + A.*B.*C + + Hadamard product commutativity: + + >>> X = HadamardProduct(A, B) + >>> Y = HadamardProduct(B, A) + >>> X + A.*B + >>> Y + B.*A + >>> canonicalize(X) + A.*B + >>> canonicalize(Y) + A.*B + + Hadamard product identity: + + >>> X = HadamardProduct(A, OneMatrix(2, 2)) + >>> X + A.*OneMatrix(2, 2) + >>> canonicalize(X) + A + + Absorbing element of Hadamard product: + + >>> X = HadamardProduct(A, ZeroMatrix(2, 2)) + >>> X + A.*0 + >>> canonicalize(X) + 0 + + Rewriting to Hadamard Power + + >>> X = HadamardProduct(A, A, A) + >>> X + A.*A.*A + >>> canonicalize(X) + A.**3 + + Notes + ===== + + As the Hadamard product is associative, nested products can be flattened. + + The Hadamard product is commutative so that factors can be sorted for + canonical form. + + A matrix of only ones is an identity for Hadamard product, + so every matrices of only ones can be removed. + + Any zero matrix will make the whole product a zero matrix. + + Duplicate elements can be collected and rewritten as HadamardPower + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Hadamard_product_(matrices) + """ + from sympy.core.compatibility import default_sort_key + + # Associativity + rule = condition( + lambda x: isinstance(x, HadamardProduct), + flatten + ) + fun = exhaust(rule) + x = fun(x) + + # Identity + fun = condition( + lambda x: isinstance(x, HadamardProduct), + rm_id(lambda x: isinstance(x, OneMatrix)) + ) + x = fun(x) + + # Absorbing by Zero Matrix + def absorb(x): + if any(isinstance(c, ZeroMatrix) for c in x.args): + return ZeroMatrix(*x.shape) + else: + return x + fun = condition( + lambda x: isinstance(x, HadamardProduct), + absorb + ) + x = fun(x) + + # Rewriting with HadamardPower + if isinstance(x, HadamardProduct): + from collections import Counter + tally = Counter(x.args) + + new_arg = [] + for base, exp in tally.items(): + if exp == 1: + new_arg.append(base) + else: + new_arg.append(HadamardPower(base, exp)) + + x = HadamardProduct(*new_arg) + + # Commutativity + fun = condition( + lambda x: isinstance(x, HadamardProduct), + sort(default_sort_key) + ) + x = fun(x) + + # Unpacking + x = unpack(x) + return x def hadamard_power(base, exp):

diff --git a/sympy/matrices/expressions/tests/test_hadamard.py b/sympy/matrices/expressions/tests/test_hadamard.py index d38e36aaa7ad..9864040fd29b 100644 --- a/sympy/matrices/expressions/tests/test_hadamard.py +++ b/sympy/matrices/expressions/tests/test_hadamard.py @@ -1,4 +1,4 @@ -from sympy import Identity +from sympy import Identity, OneMatrix, ZeroMatrix from sympy.core import symbols from sympy.utilities.pytest import raises @@ -37,12 +37,21 @@ def test_mixed_indexing(): assert (X*HadamardProduct(Y, Z))[0, 0] == \ X[0, 0]*Y[0, 0]*Z[0, 0] + X[0, 1]*Y[1, 0]*Z[1, 0] + def test_canonicalize(): X = MatrixSymbol('X', 2, 2) + Y = MatrixSymbol('Y', 2, 2) expr = HadamardProduct(X, check=False) assert isinstance(expr, HadamardProduct) expr2 = expr.doit() # unpack is called assert isinstance(expr2, MatrixSymbol) + Z = ZeroMatrix(2, 2) + U = OneMatrix(2, 2) + assert HadamardProduct(Z, X).doit() == Z + assert HadamardProduct(U, X, X, U).doit() == HadamardPower(X, 2) + assert HadamardProduct(X, U, Y).doit() == HadamardProduct(X, Y) + assert HadamardProduct(X, Z, U, Y).doit() == Z + def test_hadamard(): m, n, p = symbols('m, n, p', integer=True)

[ { "components": [ { "doc": "Canonicalize the Hadamard product ``x`` with mathematical properties.\n\nExamples\n========\n\n>>> from sympy.matrices.expressions import MatrixSymbol, HadamardProduct\n>>> from sympy.matrices.expressions import OneMatrix, ZeroMatrix\n>>> from sympy.matrices.expressions...

[ "test_canonicalize" ]

[ "test_HadamardProduct", "test_HadamardProduct_isnt_commutative", "test_mixed_indexing", "test_hadamard" ]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Canonicalization of Hadamard Product  #### References to other Issues or PRs  #### Brief description of what is fixed or changed With matrix of ones implemented in #16676, we may use the identity to make hadamard product more canonical. - [X] Associative (Default) - [X] Commutative - [X] Identity for Hadamard product by one matrix - [X] Absorbing to zero matrix when multiplied with zero matrix - [x] Rewriting to Hadamard power when repetitive matrices are multiplied. - [ ] (Optional) Reduce to diagonal matrix when multiplied with `IdentityMatrix` (Or any rectangular `eye`) After the decision is made for #16682 #### Other comments This is still work in progress, and I will add some tests if the design is set I also think that `HadamardProduct` can automatically unpack its argument, if given a single argument, like in SymPy's `Add`, `Mul`. As it is confusing that `HadamardProduct(A) == A` is giving `False` because it does not unpacks single arguent but `hadamard_product(A) == A` is giving `True`. And the printing is not suggestive that `HadamardProduct` is wrapped on this. Though changing this would make some tests fail, and there may be some discussion for design change? #### Release Notes   - matrices - Improved canonicalization for `HadamardProduct` - Deleted `rules` from `matrices.expressions.hadamard`  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/matrices/expressions/hadamard.py] (definition of canonicalize:) def canonicalize(x): """Canonicalize the Hadamard product ``x`` with mathematical properties. Examples ======== >>> from sympy.matrices.expressions import MatrixSymbol, HadamardProduct >>> from sympy.matrices.expressions import OneMatrix, ZeroMatrix >>> from sympy.matrices.expressions.hadamard import canonicalize >>> A = MatrixSymbol('A', 2, 2) >>> B = MatrixSymbol('B', 2, 2) >>> C = MatrixSymbol('C', 2, 2) Hadamard product associativity: >>> X = HadamardProduct(A, HadamardProduct(B, C)) >>> X A.*(B.*C) >>> canonicalize(X) A.*B.*C Hadamard product commutativity: >>> X = HadamardProduct(A, B) >>> Y = HadamardProduct(B, A) >>> X A.*B >>> Y B.*A >>> canonicalize(X) A.*B >>> canonicalize(Y) A.*B Hadamard product identity: >>> X = HadamardProduct(A, OneMatrix(2, 2)) >>> X A.*OneMatrix(2, 2) >>> canonicalize(X) A Absorbing element of Hadamard product: >>> X = HadamardProduct(A, ZeroMatrix(2, 2)) >>> X A.*0 >>> canonicalize(X) 0 Rewriting to Hadamard Power >>> X = HadamardProduct(A, A, A) >>> X A.*A.*A >>> canonicalize(X) A.**3 Notes ===== As the Hadamard product is associative, nested products can be flattened. The Hadamard product is commutative so that factors can be sorted for canonical form. A matrix of only ones is an identity for Hadamard product, so every matrices of only ones can be removed. Any zero matrix will make the whole product a zero matrix. Duplicate elements can be collected and rewritten as HadamardPower References ========== .. [1] https://en.wikipedia.org/wiki/Hadamard_product_(matrices)""" (definition of canonicalize.absorb:) def absorb(x): [end of new definitions in sympy/matrices/expressions/hadamard.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-16676

16,676

sympy/sympy

1.5

6da0ab837c472e933145cf37fd2ab0634ffa1aa6

2019-04-17T22:34:46Z

diff --git a/sympy/matrices/expressions/matexpr.py b/sympy/matrices/expressions/matexpr.py index b90c9cc933b7..8e4da20e3fa0 100644 --- a/sympy/matrices/expressions/matexpr.py +++ b/sympy/matrices/expressions/matexpr.py @@ -980,6 +980,45 @@ def __hash__(self): return super(GenericZeroMatrix, self).__hash__() +class OneMatrix(MatrixExpr): + """ + Matrix whose all entries are ones. + """ + def __new__(cls, m, n): + obj = super(OneMatrix, cls).__new__(cls, m, n) + return obj + + @property + def shape(self): + return self._args + + def as_explicit(self): + from sympy import ImmutableDenseMatrix + return ImmutableDenseMatrix.ones(*self.shape) + + def _eval_transpose(self): + return OneMatrix(self.cols, self.rows) + + def _eval_trace(self): + return S.One*self.rows + + def _eval_determinant(self): + condition = Eq(self.shape[0], 1) & Eq(self.shape[1], 1) + if condition == True: + return S.One + elif condition == False: + return S.Zero + else: + from sympy import Determinant + return Determinant(self) + + def conjugate(self): + return self + + def _entry(self, i, j, **kwargs): + return S.One + + def matrix_symbols(expr): return [sym for sym in expr.free_symbols if sym.is_Matrix]

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index eac4113f90c5..7d8ea35b66cf 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -2688,6 +2688,12 @@ def test_sympy__matrices__expressions__matexpr__ZeroMatrix(): from sympy.matrices.expressions.matexpr import ZeroMatrix assert _test_args(ZeroMatrix(3, 5)) + +def test_sympy__matrices__expressions__matexpr__OneMatrix(): + from sympy.matrices.expressions.matexpr import OneMatrix + assert _test_args(OneMatrix(3, 5)) + + def test_sympy__matrices__expressions__matexpr__GenericZeroMatrix(): from sympy.matrices.expressions.matexpr import GenericZeroMatrix assert _test_args(GenericZeroMatrix()) diff --git a/sympy/matrices/expressions/tests/test_determinant.py b/sympy/matrices/expressions/tests/test_determinant.py index 440bcd290418..9b0b347f92e4 100644 --- a/sympy/matrices/expressions/tests/test_determinant.py +++ b/sympy/matrices/expressions/tests/test_determinant.py @@ -4,6 +4,7 @@ Identity, MatrixExpr, MatrixSymbol, Determinant, det, ZeroMatrix, Transpose ) +from sympy.matrices.expressions.matexpr import OneMatrix from sympy.utilities.pytest import raises from sympy import refine, Q @@ -28,6 +29,9 @@ def test_det(): def test_eval_determinant(): assert det(Identity(n)) == 1 assert det(ZeroMatrix(n, n)) == 0 + assert det(OneMatrix(n, n)) == Determinant(OneMatrix(n, n)) + assert det(OneMatrix(1, 1)) == 1 + assert det(OneMatrix(2, 2)) == 0 assert det(Transpose(A)) == det(A) diff --git a/sympy/matrices/expressions/tests/test_matexpr.py b/sympy/matrices/expressions/tests/test_matexpr.py index d6e66f545f30..9fa4e1c806cd 100644 --- a/sympy/matrices/expressions/tests/test_matexpr.py +++ b/sympy/matrices/expressions/tests/test_matexpr.py @@ -9,7 +9,7 @@ MatPow, Matrix, MatrixExpr, MatrixSymbol, ShapeError, ZeroMatrix, SparseMatrix, Transpose, Adjoint) from sympy.matrices.expressions.matexpr import (MatrixElement, - GenericZeroMatrix, GenericIdentity) + GenericZeroMatrix, GenericIdentity, OneMatrix) from sympy.utilities.pytest import raises, XFAIL @@ -76,6 +76,36 @@ def test_ZeroMatrix_doit(): assert isinstance(Znn.doit().rows, Mul) +def test_OneMatrix(): + A = MatrixSymbol('A', n, m) + a = MatrixSymbol('a', n, 1) + U = OneMatrix(n, m) + + assert U.shape == (n, m) + assert isinstance(A + U, Add) + assert transpose(U) == OneMatrix(m, n) + assert U.conjugate() == U + + assert OneMatrix(n, n) ** 0 == Identity(n) + with raises(ShapeError): + U ** 0 + with raises(ShapeError): + U ** 2 + + U = OneMatrix(n, n) + assert U[1, 2] == 1 + + U = OneMatrix(2, 3) + assert U.as_explicit() == ImmutableMatrix.ones(2, 3) + + +def test_OneMatrix_doit(): + Unn = OneMatrix(Add(n, n, evaluate=False), n) + assert isinstance(Unn.rows, Add) + assert Unn.doit() == OneMatrix(2 * n, n) + assert isinstance(Unn.doit().rows, Mul) + + def test_Identity(): A = MatrixSymbol('A', n, m) i, j = symbols('i j') diff --git a/sympy/matrices/expressions/tests/test_trace.py b/sympy/matrices/expressions/tests/test_trace.py index b8d4a570868f..8682c9470ef1 100644 --- a/sympy/matrices/expressions/tests/test_trace.py +++ b/sympy/matrices/expressions/tests/test_trace.py @@ -6,6 +6,7 @@ Adjoint, Identity, FunctionMatrix, MatrixExpr, MatrixSymbol, Trace, ZeroMatrix, trace, MatPow, MatAdd, MatMul ) +from sympy.matrices.expressions.matexpr import OneMatrix from sympy.utilities.pytest import raises, XFAIL n = symbols('n', integer=True) @@ -30,6 +31,9 @@ def test_Trace(): # Some easy simplifications assert trace(Identity(5)) == 5 assert trace(ZeroMatrix(5, 5)) == 0 + assert trace(OneMatrix(1, 1)) == 1 + assert trace(OneMatrix(2, 2)) == 2 + assert trace(OneMatrix(n, n)) == n assert trace(2*A*B) == 2*Trace(A*B) assert trace(A.T) == trace(A)

[ { "components": [ { "doc": "Matrix whose all entries are ones.", "lines": [ 983, 1019 ], "name": "OneMatrix", "signature": "class OneMatrix(MatrixExpr):", "type": "class" }, { "doc": "", "lines": [ 98...

[ "test_sympy__matrices__expressions__matexpr__OneMatrix", "test_det", "test_eval_determinant", "test_shape", "test_matexpr", "test_subs", "test_ZeroMatrix", "test_ZeroMatrix_doit", "test_OneMatrix", "test_OneMatrix_doit", "test_Identity", "test_Identity_doit", "test_addition", "test_multipl...

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> added OneMatrix for matrix expressions with only ones  #### References to other Issues or PRs  #### Brief description of what is fixed or changed #### Other comments #### Release Notes   * matrices * Introduction of `OneMatrix`, a matrix symbol representing matrices of only 1 entries.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/matrices/expressions/matexpr.py] (definition of OneMatrix:) class OneMatrix(MatrixExpr): """Matrix whose all entries are ones.""" (definition of OneMatrix.__new__:) def __new__(cls, m, n): (definition of OneMatrix.shape:) def shape(self): (definition of OneMatrix.as_explicit:) def as_explicit(self): (definition of OneMatrix._eval_transpose:) def _eval_transpose(self): (definition of OneMatrix._eval_trace:) def _eval_trace(self): (definition of OneMatrix._eval_determinant:) def _eval_determinant(self): (definition of OneMatrix.conjugate:) def conjugate(self): (definition of OneMatrix._entry:) def _entry(self, i, j, **kwargs): [end of new definitions in sympy/matrices/expressions/matexpr.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

conan-io__conan-4963

4,963

conan-io/conan

null

84a38590987ecb9f3011f73babc95598ea62535f

2019-04-12T10:24:34Z

diff --git a/conans/client/tools/version.py b/conans/client/tools/version.py new file mode 100644 index 00000000000..7822658781b --- /dev/null +++ b/conans/client/tools/version.py @@ -0,0 +1,50 @@ +# coding=utf-8 + +from functools import total_ordering + +from semver import SemVer + +from conans.errors import ConanException + + +@total_ordering +class Version(object): + _semver = None + loose = True # Allow incomplete version strings like '1.2' or '1-dev0' + + def __init__(self, value): + v = str(value).strip() + try: + self._semver = SemVer(v, loose=self.loose) + except ValueError: + raise ConanException("Invalid version '{}'".format(value)) + + @property + def major(self): + return str(self._semver.major) + + @property + def minor(self): + return str(self._semver.minor) + + @property + def patch(self): + return str(self._semver.patch) + + @property + def prerelease(self): + return str(".".join(map(str, self._semver.prerelease))) + + @property + def build(self): + return str(".".join(map(str, self._semver.build))) + + def __eq__(self, other): + if not isinstance(other, Version): + other = Version(other) + return self._semver.compare(other._semver) == 0 + + def __lt__(self, other): + if not isinstance(other, Version): + other = Version(other) + return self._semver.compare(other._semver) < 0 diff --git a/conans/tools.py b/conans/tools.py index 2f28a95f128..ee26518eaf0 100644 --- a/conans/tools.py +++ b/conans/tools.py @@ -26,6 +26,7 @@ rmdir, save as files_save, save_append, sha1sum, sha256sum, touch, sha1sum, sha256sum, \ to_file_bytes, touch from conans.util.log import logger +from conans.client.tools.version import Version # This global variables are intended to store the configuration of the running Conan application

diff --git a/conans/test/unittests/client/tools/test_version.py b/conans/test/unittests/client/tools/test_version.py new file mode 100644 index 00000000000..46ca9a3983a --- /dev/null +++ b/conans/test/unittests/client/tools/test_version.py @@ -0,0 +1,111 @@ +# coding=utf-8 + + +import unittest + +import six + +from conans.client.tools.version import Version +from conans.errors import ConanException + + +class ToolVersionMainComponentsTests(unittest.TestCase): + + def test_invalid_values(self): + self.assertRaises(ConanException, Version, "") + self.assertRaises(ConanException, Version, "nonsense") + self.assertRaises(ConanException, Version, "a1.2.3") + + def test_invalid_message(self): + with six.assertRaisesRegex(self, ConanException, "Invalid version 'not-valid'"): + Version("not-valid") + + def test_valid_values(self): + for v_str in ["1.2.3", "1.2.3-dev90", "1.2.3+dev90", "1.2.3-dev90+more", "1.2.3-dev90+a.b"]: + v = Version(v_str) + self.assertEqual(v.major, "1") + self.assertEqual(v.minor, "2") + self.assertEqual(v.patch, "3") + + def test_valid_loose(self): + self.assertTrue(Version.loose) + + # These versions are considered valid with loose validation + self.assertTrue(Version.loose) + v = Version("1.2") + self.assertEqual(v.major, "1") + self.assertEqual(v.minor, "2") + self.assertEqual(v.patch, "0") + + v = Version("1") + self.assertEqual(v.major, "1") + self.assertEqual(v.minor, "0") + self.assertEqual(v.patch, "0") + + v = Version(" 1a") + self.assertEqual(v.major, "1") + self.assertEqual(v.minor, "0") + self.assertEqual(v.patch, "0") + + def test_convert_str(self): + # Check that we are calling the string method + class A(object): + def __str__(self): + return "1.2.3" + + v = Version(A()) + self.assertEqual(v.major, "1") + self.assertEqual(v.minor, "2") + self.assertEqual(v.patch, "3") + + def test_compare(self): + self.assertTrue(Version("1.2.3") == "1.2.3") + self.assertTrue(Version("1.2.3") == Version("1.2.3")) + + self.assertTrue(Version.loose) + self.assertTrue(Version("234") == "234") + self.assertTrue(Version("234") == Version("234")) + + def test_gt(self): + self.assertTrue(Version("1.2.3") > "1.2.2") + + self.assertTrue(Version.loose) + self.assertTrue(Version("1.2") > "1") + self.assertTrue(Version("1.2") > Version("1")) + + self.assertFalse(Version("1.0") > "1") + self.assertFalse(Version("1.0.0") > "1") + self.assertFalse(Version("1") > "1.0") + self.assertFalse(Version("1") > "1.0.0") + + +class ToolVersionExtraComponentsTests(unittest.TestCase): + + def test_parsing(self): + v = Version("1.2.3-dev.90.80-dev2+build.b1.b2") + self.assertEqual(v.prerelease, "dev.90.80-dev2") + self.assertEqual(v.build, "build.b1.b2") + + v = Version("1.2.305-dev4") + self.assertEqual(v.prerelease, "dev4") + self.assertEqual(v.build, "") + + v = Version("1.2.305+dev4") + self.assertEqual(v.prerelease, "") + self.assertEqual(v.build, "dev4") + + def test_compare(self): + # prerelease is taken into account + self.assertTrue(Version("1.2.3-dev90") != "1.2.3") + self.assertTrue(Version("1.2.3-dev90") < "1.2.3") + self.assertTrue(Version("1.2.3-dev90") < Version("1.2.3")) + + # build is not taken into account + self.assertTrue(Version("1.2") == Version("1.2+dev0")) + self.assertFalse(Version("1.2") > Version("1.2+dev0")) + self.assertFalse(Version("1.2") < Version("1.2+dev0")) + + # Unknown release field, not fail (loose=True) and don't affect compare + self.assertTrue(Version.loose) + self.assertTrue(Version("1.2.3.4") == Version("1.2.3")) +

[ { "components": [ { "doc": "", "lines": [ 11, 50 ], "name": "Version", "signature": "class Version(object):", "type": "class" }, { "doc": "", "lines": [ 15, 20 ], "name": "Ve...

[ "conans/test/unittests/client/tools/test_version.py::ToolVersionMainComponentsTests::test_compare", "conans/test/unittests/client/tools/test_version.py::ToolVersionMainComponentsTests::test_convert_str", "conans/test/unittests/client/tools/test_version.py::ToolVersionMainComponentsTests::test_gt", "conans/tes...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Implement tools.Version (based on SemVer) Changelog: Feature: Create `tools.Version` with _limited_ capabilities Docs: https://github.com/conan-io/docs/pull/1253 * I'm using `loose=True` to allow incomplete versions like `1.2` (no _patch_ component) or "2" (no _minor_ nor _patch_) closes https://github.com/conan-io/conan/issues/4875 _Note.- Supersedes https://github.com/conan-io/conan/pull/4949_ ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conans/client/tools/version.py] (definition of Version:) class Version(object): (definition of Version.__init__:) def __init__(self, value): (definition of Version.major:) def major(self): (definition of Version.minor:) def minor(self): (definition of Version.patch:) def patch(self): (definition of Version.prerelease:) def prerelease(self): (definition of Version.build:) def build(self): (definition of Version.__eq__:) def __eq__(self, other): (definition of Version.__lt__:) def __lt__(self, other): [end of new definitions in conans/client/tools/version.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

4a5b19a75db9225316c8cb022a2dfb9705a2af34

scrapy__scrapy-3739

3,739

scrapy/scrapy

null

6e49c379a8ecfe92c99a37b6bb6d7e440df56bd9

2019-04-10T11:08:17Z

diff --git a/docs/topics/contracts.rst b/docs/topics/contracts.rst index 70f20d4ed36..9337375bb7c 100644 --- a/docs/topics/contracts.rst +++ b/docs/topics/contracts.rst @@ -120,3 +120,23 @@ get the failures pretty printed:: for header in self.args: if header not in response.headers: raise ContractFail('X-CustomHeader not present') + + +Detecting check runs +==================== + +When ``scrapy check`` is running, the ``SCRAPY_CHECK`` environment variable is +set to the ``true`` string. You can use `os.environ`_ to perform any change to +your spiders or your settings when ``scrapy check`` is used:: + + import os + import scrapy + + class ExampleSpider(scrapy.Spider): + name = 'example' + + def __init__(self): + if os.environ.get('SCRAPY_CHECK'): + pass # Do some scraper adjustments when a check is running + +.. _os.environ: https://docs.python.org/3/library/os.html#os.environ diff --git a/scrapy/utils/misc.py b/scrapy/utils/misc.py index ddaa7f7bf32..f638adb25a2 100644 --- a/scrapy/utils/misc.py +++ b/scrapy/utils/misc.py @@ -1,6 +1,8 @@ """Helper functions which don't fit anywhere else""" +import os import re import hashlib +from contextlib import contextmanager from importlib import import_module from pkgutil import iter_modules @@ -142,3 +144,21 @@ def create_instance(objcls, settings, crawler, *args, **kwargs): return objcls.from_settings(settings, *args, **kwargs) else: return objcls(*args, **kwargs) + + +@contextmanager +def set_environ(**kwargs): + """Temporarily set environment variables inside the context manager and + fully restore previous environment afterwards + """ + + original_env = {k: os.environ.get(k) for k in kwargs} + os.environ.update(kwargs) + try: + yield + finally: + for k, v in original_env.items(): + if v is None: + del os.environ[k] + else: + os.environ[k] = v

diff --git a/scrapy/commands/check.py b/scrapy/commands/check.py index b8a9ef989e7..ab73e85e7fb 100644 --- a/scrapy/commands/check.py +++ b/scrapy/commands/check.py @@ -6,7 +6,7 @@ from scrapy.commands import ScrapyCommand from scrapy.contracts import ContractsManager -from scrapy.utils.misc import load_object +from scrapy.utils.misc import load_object, set_environ from scrapy.utils.conf import build_component_list @@ -68,16 +68,17 @@ def run(self, args, opts): spider_loader = self.crawler_process.spider_loader - for spidername in args or spider_loader.list(): - spidercls = spider_loader.load(spidername) - spidercls.start_requests = lambda s: conman.from_spider(s, result) - - tested_methods = conman.tested_methods_from_spidercls(spidercls) - if opts.list: - for method in tested_methods: - contract_reqs[spidercls.name].append(method) - elif tested_methods: - self.crawler_process.crawl(spidercls) + with set_environ(SCRAPY_CHECK='true'): + for spidername in args or spider_loader.list(): + spidercls = spider_loader.load(spidername) + spidercls.start_requests = lambda s: conman.from_spider(s, result) + + tested_methods = conman.tested_methods_from_spidercls(spidercls) + if opts.list: + for method in tested_methods: + contract_reqs[spidercls.name].append(method) + elif tested_methods: + self.crawler_process.crawl(spidercls) # start checks if opts.list: diff --git a/tests/test_utils_misc/__init__.py b/tests/test_utils_misc/__init__.py index fcb7772ab43..e109d53436e 100644 --- a/tests/test_utils_misc/__init__.py +++ b/tests/test_utils_misc/__init__.py @@ -3,12 +3,13 @@ import unittest from scrapy.item import Item, Field -from scrapy.utils.misc import arg_to_iter, create_instance, load_object, walk_modules +from scrapy.utils.misc import arg_to_iter, create_instance, load_object, set_environ, walk_modules from tests import mock __doctests__ = ['scrapy.utils.misc'] + class UtilsMiscTestCase(unittest.TestCase): def test_load_object(self): @@ -130,5 +131,18 @@ def _test_with_crawler(mock, settings, crawler): with self.assertRaises(ValueError): create_instance(m, None, None) + def test_set_environ(self): + assert os.environ.get('some_test_environ') is None + with set_environ(some_test_environ='test_value'): + assert os.environ.get('some_test_environ') == 'test_value' + assert os.environ.get('some_test_environ') is None + + os.environ['some_test_environ'] = 'test' + assert os.environ.get('some_test_environ') == 'test' + with set_environ(some_test_environ='test_value'): + assert os.environ.get('some_test_environ') == 'test_value' + assert os.environ.get('some_test_environ') == 'test' + + if __name__ == "__main__": unittest.main()

diff --git a/docs/topics/contracts.rst b/docs/topics/contracts.rst index 70f20d4ed36..9337375bb7c 100644 --- a/docs/topics/contracts.rst +++ b/docs/topics/contracts.rst @@ -120,3 +120,23 @@ get the failures pretty printed:: for header in self.args: if header not in response.headers: raise ContractFail('X-CustomHeader not present') + + +Detecting check runs +==================== + +When ``scrapy check`` is running, the ``SCRAPY_CHECK`` environment variable is +set to the ``true`` string. You can use `os.environ`_ to perform any change to +your spiders or your settings when ``scrapy check`` is used:: + + import os + import scrapy + + class ExampleSpider(scrapy.Spider): + name = 'example' + + def __init__(self): + if os.environ.get('SCRAPY_CHECK'): + pass # Do some scraper adjustments when a check is running + +.. _os.environ: https://docs.python.org/3/library/os.html#os.environ

[ { "components": [ { "doc": "Temporarily set environment variables inside the context manager and\nfully restore previous environment afterwards", "lines": [ 150, 164 ], "name": "set_environ", "signature": "def set_environ(**kwargs):", "ty...

[ "tests/test_utils_misc/__init__.py::UtilsMiscTestCase::test_arg_to_iter", "tests/test_utils_misc/__init__.py::UtilsMiscTestCase::test_create_instance", "tests/test_utils_misc/__init__.py::UtilsMiscTestCase::test_load_object", "tests/test_utils_misc/__init__.py::UtilsMiscTestCase::test_set_environ", "tests/t...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG+1] Add SCRAPY_CHECK environment variable This PR implements the environment variable when running `scrapy check` as asked in #3704 . This way it is possible to have different behaviour in the scraper when running the check (like requiring less settings to be set) fixes #3704 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in scrapy/utils/misc.py] (definition of set_environ:) def set_environ(**kwargs): """Temporarily set environment variables inside the context manager and fully restore previous environment afterwards""" [end of new definitions in scrapy/utils/misc.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Set environment variable when running scrapy check Sometimes it is nice to be able to enable/disable functionality, e.g. calculating things in settings.py when just checking spider contracts instead of running a crawl. I therefor propose setting an environment variable like `SCRAPY_CHECK` when using the check command. ---------- -------------------- </issues>

57a5460529ff71c42e4d0381265b1b512b1eb09b

sympy__sympy-16576

16,576

sympy/sympy

1.5

c9330b1a062174f5d38bbbbc7afb2f47e2e72d6a

2019-04-06T17:54:46Z

diff --git a/sympy/stats/joint_rv_types.py b/sympy/stats/joint_rv_types.py index 5f3ecbdc9894..de452368a5ef 100644 --- a/sympy/stats/joint_rv_types.py +++ b/sympy/stats/joint_rv_types.py @@ -1,5 +1,6 @@ -from sympy import (sympify, S, pi, sqrt, exp, Lambda, Indexed, Gt, - IndexedBase, besselk, gamma, Interval, Range, factorial, Mul, Integer) +from sympy import (sympify, S, pi, sqrt, exp, Lambda, Indexed, Gt, IndexedBase, + besselk, gamma, Interval, Range, factorial, Mul, Integer, + Add, rf, Eq, Piecewise) from sympy.matrices import ImmutableMatrix from sympy.matrices.expressions.determinant import det from sympy.stats.joint_rv import (JointDistribution, JointPSpace, @@ -249,6 +250,150 @@ def NormalGamma(syms, mu, lamda, alpha, beta): """ return multivariate_rv(NormalGammaDistribution, syms, mu, lamda, alpha, beta) +#------------------------------------------------------------------------------- +# Multivariate Beta/Dirichlet distribution --------------------------------------------------------- + +class MultivariateBetaDistribution(JointDistribution): + + _argnames = ['alpha'] + is_Continuous = True + + def check(self, alpha): + _value_check(len(alpha) >= 2, "At least two categories should be passed.") + for a_k in alpha: + _value_check((a_k > 0) != False, "Each concentration parameter" + " should be positive.") + + @property + def set(self): + k = len(self.alpha) + return Interval(0, 1)**k + + def pdf(self, *syms): + alpha = self.alpha + B = Mul.fromiter(map(gamma, alpha))/gamma(Add(*alpha)) + return Mul.fromiter([sym**(a_k - 1) for a_k, sym in zip(alpha, syms)])/B + +def MultivariateBeta(syms, *alpha): + """ + Creates a continuous random variable with Dirichlet/Multivariate Beta + Distribution. + + The density of the dirichlet distribution can be found at [1]. + + Parameters + ========== + + alpha: positive real numbers signifying concentration numbers. + + Returns + ======= + + A RandomSymbol. + + Examples + ======== + + >>> from sympy.stats import density + >>> from sympy.stats.joint_rv import marginal_distribution + >>> from sympy.stats.joint_rv_types import MultivariateBeta + >>> from sympy import Symbol + >>> a1 = Symbol('a1', positive=True) + >>> a2 = Symbol('a2', positive=True) + >>> B = MultivariateBeta('B', [a1, a2]) + >>> C = MultivariateBeta('C', a1, a2) + >>> x = Symbol('x') + >>> y = Symbol('y') + >>> density(B)(x, y) + x**(a1 - 1)*y**(a2 - 1)*gamma(a1 + a2)/(gamma(a1)*gamma(a2)) + >>> marginal_distribution(C, C[0])(x) + x**(a1 - 1)*gamma(a1 + a2)/(a2*gamma(a1)*gamma(a2)) + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Dirichlet_distribution + .. [2] http://mathworld.wolfram.com/DirichletDistribution.html + + """ + if not isinstance(alpha[0], list): + alpha = (list(alpha),) + return multivariate_rv(MultivariateBetaDistribution, syms, alpha[0]) + +Dirichlet = MultivariateBeta + +#------------------------------------------------------------------------------- +# Multivariate Ewens distribution --------------------------------------------------------- + +class MultivariateEwensDistribution(JointDistribution): + + _argnames = ['n', 'theta'] + is_Discrete = True + is_Continuous = False + + def check(self, n, theta): + _value_check(isinstance(n, Integer) and (n > 0) == True, + "sample size should be positive integer.") + _value_check(theta.is_positive, "mutation rate should be positive.") + + @property + def set(self): + prod_set = Range(0, self.n//1 + 1) + for i in range(2, self.n + 1): + prod_set *= Range(0, self.n//i + 1) + return prod_set + + def pdf(self, *syms): + n, theta = self.n, self.theta + term_1 = factorial(n)/rf(theta, n) + term_2 = Mul.fromiter([theta**syms[j]/((j+1)**syms[j]*factorial(syms[j])) + for j in range(n)]) + cond = Eq(sum([(k+1)*syms[k] for k in range(n)]), n) + return Piecewise((term_1 * term_2, cond), (0, True)) + +def MultivariateEwens(syms, n, theta): + """ + Creates a discrete random variable with Multivariate Ewens + Distribution. + + The density of the said distribution can be found at [1]. + + Parameters + ========== + + n: postive integer of class Integer, + size of the sample or the integer whose partitions are considered + theta: mutation rate, must be positive real number. + + Returns + ======= + + A RandomSymbol. + + Examples + ======== + + >>> from sympy.stats import density + >>> from sympy.stats.joint_rv import marginal_distribution + >>> from sympy.stats.joint_rv_types import MultivariateEwens + >>> from sympy import Symbol + >>> a1 = Symbol('a1', positive=True) + >>> a2 = Symbol('a2', positive=True) + >>> ed = MultivariateEwens('E', 2, 1) + >>> density(ed)(a1, a2) + Piecewise((2**(-a2)/(factorial(a1)*factorial(a2)), Eq(a1 + 2*a2, 2)), (0, True)) + >>> marginal_distribution(ed, ed[0])(a1) + Piecewise((1/factorial(a1), Eq(a1, 2)), (0, True)) + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Ewens%27s_sampling_formula + .. [2] http://www.stat.rutgers.edu/home/hcrane/Papers/STS529.pdf + + """ + return multivariate_rv(MultivariateEwensDistribution, syms, n, theta) + #------------------------------------------------------------------------------- # Multinomial distribution ---------------------------------------------------------

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index b86a8d3dd501..29d785737a6a 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -1496,6 +1496,14 @@ def test_sympy__stats__joint_rv_types__NormalGammaDistribution(): from sympy.stats.joint_rv_types import NormalGammaDistribution assert _test_args(NormalGammaDistribution(1, 2, 3, 4)) +def test_sympy__stats__joint_rv_types__MultivariateBetaDistribution(): + from sympy.stats.joint_rv_types import MultivariateBetaDistribution + assert _test_args(MultivariateBetaDistribution([1, 2, 3])) + +def test_sympy__stats__joint_rv_types__MultivariateEwensDistribution(): + from sympy.stats.joint_rv_types import MultivariateEwensDistribution + assert _test_args(MultivariateEwensDistribution(5, 1)) + def test_sympy__stats__joint_rv_types__MultinomialDistribution(): from sympy.stats.joint_rv_types import MultinomialDistribution assert _test_args(MultinomialDistribution(5, [0.5, 0.1, 0.3])) diff --git a/sympy/stats/tests/test_joint_rv.py b/sympy/stats/tests/test_joint_rv.py index a9ae6e2c7b4b..63940393791b 100644 --- a/sympy/stats/tests/test_joint_rv.py +++ b/sympy/stats/tests/test_joint_rv.py @@ -1,5 +1,5 @@ -from sympy import (symbols, pi, oo, S, exp, sqrt, besselk, Indexed, factorial, - simplify, gamma) +from sympy import (symbols, pi, oo, S, exp, sqrt, besselk, Indexed, Rational, + simplify, Piecewise, factorial, Eq, gamma) from sympy.stats import density from sympy.stats.joint_rv import marginal_distribution from sympy.stats.joint_rv_types import JointRV @@ -54,6 +54,41 @@ def test_NormalGamma(): 3*sqrt(10)*gamma(S(7)/4)/(10*sqrt(pi)*gamma(S(5)/4)) assert marginal_distribution(ng, y)(1) == exp(-S(1)/4)/128 +def test_MultivariateBeta(): + from sympy.stats.joint_rv_types import MultivariateBeta + from sympy import gamma + a1, a2 = symbols('a1, a2', positive=True) + a1_f, a2_f = symbols('a1, a2', positive=False) + mb = MultivariateBeta('B', [a1, a2]) + mb_c = MultivariateBeta('C', a1, a2) + assert density(mb)(1, 2) == S(2)**(a2 - 1)*gamma(a1 + a2)/\ + (gamma(a1)*gamma(a2)) + assert marginal_distribution(mb_c, 0)(3) == S(3)**(a1 - 1)*gamma(a1 + a2)/\ + (a2*gamma(a1)*gamma(a2)) + raises(ValueError, lambda: MultivariateBeta('b1', [a1_f, a2])) + raises(ValueError, lambda: MultivariateBeta('b2', [a1, a2_f])) + raises(ValueError, lambda: MultivariateBeta('b3', [0, 0])) + raises(ValueError, lambda: MultivariateBeta('b4', [a1_f, a2_f])) + +def test_MultivariateEwens(): + from sympy.stats.joint_rv_types import MultivariateEwens + n, theta = symbols('n theta', positive=True) + theta_f = symbols('t_f', negative=True) + a = symbols('a_1:4', positive = True, integer = True) + ed = MultivariateEwens('E', 3, theta) + assert density(ed)(a[0], a[1], a[2]) == Piecewise((6*2**(-a[1])*3**(-a[2])* + theta**a[0]*theta**a[1]*theta**a[2]/ + (theta*(theta + 1)*(theta + 2)* + factorial(a[0])*factorial(a[1])* + factorial(a[2])), Eq(a[0] + 2*a[1] + + 3*a[2], 3)), (0, True)) + assert marginal_distribution(ed, ed[1])(a[1]) == Piecewise((6*2**(-a[1])* + theta**a[1]/((theta + 1)* + (theta + 2)*factorial(a[1])), + Eq(2*a[1] + 1, 3)), (0, True)) + raises(ValueError, lambda: MultivariateEwens('e1', 5, theta_f)) + raises(ValueError, lambda: MultivariateEwens('e1', n, theta)) + def test_Multinomial(): from sympy.stats.joint_rv_types import Multinomial n, x1, x2, x3, x4 = symbols('n, x1, x2, x3, x4', nonnegative=True, integer=True)

[ { "components": [ { "doc": "", "lines": [ 256, 275 ], "name": "MultivariateBetaDistribution", "signature": "class MultivariateBetaDistribution(JointDistribution):", "type": "class" }, { "doc": "", "lines": [ ...

[ "test_sympy__stats__joint_rv_types__MultivariateBetaDistribution", "test_sympy__stats__joint_rv_types__MultivariateEwensDistribution", "test_MultivariateBeta", "test_MultivariateEwens" ]

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Addition of Dirichlet, Ewens Distributions  #### References  [1] [GSoC Proposal](https://docs.google.com/document/d/1oIeaROiJyglpbris7X1uZPRE5ZeO0pD1ygCFhBIeATI/edit#heading=h.wb8kk2gus2ng) by @czgdp1807 [2] [GSoC Proposal](https://github.com/ritesh99rakesh/gsocProposal/blob/master/SymPy.md) by @ritesh99rakesh #### Brief description of what is fixed or changed MultivariateBetaDistribution has been added to sympy.stats.joint_rv_types. More distributions will be added after reviewing the previous one added. #### Other comments I want to use `Beta` in `sympy.stats.crv_types` for making random symbols following `MultivariateBetaDistribution` as is `Normal` being used for `MultivariateNormalDistribution`. However, the reason restricting me for using `Beta` is the difference in the way parameters are passed to the `Beta` function and `MultivariateBeta` function. The former one accepts `alpha`, `beta` as arguments and the latter one accepts, a single vector or pythonically, list, `alpha`. One solution in my mind is to use, `Beta(name, *alpha)`, for both univariate and multivariate Beta distributions. The length of and type of `*alpha` can be used as the deciding factor for returning either return `multivariate_rv` or `rv`. Edit - As said in [this comment](https://github.com/sympy/sympy/pull/16576#issuecomment-491218778) below, I think using `Beta` for `MultivariateBeta` or `Dirichlet` distribution is not a good idea because, most people use `Dirichlet` to denote `MultivariateBetaDistribution`, so mixing up the two distributions is not valid. However, both, `MultivariateBeta` and `Dirichlet` can be used to denote `MultivariateBetaDistributions` . #### Release Notes   * stats * multivariate distributions added to sympy.stats.joint_rv_types  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/stats/joint_rv_types.py] (definition of MultivariateBetaDistribution:) class MultivariateBetaDistribution(JointDistribution): (definition of MultivariateBetaDistribution.check:) def check(self, alpha): (definition of MultivariateBetaDistribution.set:) def set(self): (definition of MultivariateBetaDistribution.pdf:) def pdf(self, *syms): (definition of MultivariateBeta:) def MultivariateBeta(syms, *alpha): """Creates a continuous random variable with Dirichlet/Multivariate Beta Distribution. The density of the dirichlet distribution can be found at [1]. Parameters ========== alpha: positive real numbers signifying concentration numbers. Returns ======= A RandomSymbol. Examples ======== >>> from sympy.stats import density >>> from sympy.stats.joint_rv import marginal_distribution >>> from sympy.stats.joint_rv_types import MultivariateBeta >>> from sympy import Symbol >>> a1 = Symbol('a1', positive=True) >>> a2 = Symbol('a2', positive=True) >>> B = MultivariateBeta('B', [a1, a2]) >>> C = MultivariateBeta('C', a1, a2) >>> x = Symbol('x') >>> y = Symbol('y') >>> density(B)(x, y) x**(a1 - 1)*y**(a2 - 1)*gamma(a1 + a2)/(gamma(a1)*gamma(a2)) >>> marginal_distribution(C, C[0])(x) x**(a1 - 1)*gamma(a1 + a2)/(a2*gamma(a1)*gamma(a2)) References ========== .. [1] https://en.wikipedia.org/wiki/Dirichlet_distribution .. [2] http://mathworld.wolfram.com/DirichletDistribution.html""" (definition of MultivariateEwensDistribution:) class MultivariateEwensDistribution(JointDistribution): (definition of MultivariateEwensDistribution.check:) def check(self, n, theta): (definition of MultivariateEwensDistribution.set:) def set(self): (definition of MultivariateEwensDistribution.pdf:) def pdf(self, *syms): (definition of MultivariateEwens:) def MultivariateEwens(syms, n, theta): """Creates a discrete random variable with Multivariate Ewens Distribution. The density of the said distribution can be found at [1]. Parameters ========== n: postive integer of class Integer, size of the sample or the integer whose partitions are considered theta: mutation rate, must be positive real number. Returns ======= A RandomSymbol. Examples ======== >>> from sympy.stats import density >>> from sympy.stats.joint_rv import marginal_distribution >>> from sympy.stats.joint_rv_types import MultivariateEwens >>> from sympy import Symbol >>> a1 = Symbol('a1', positive=True) >>> a2 = Symbol('a2', positive=True) >>> ed = MultivariateEwens('E', 2, 1) >>> density(ed)(a1, a2) Piecewise((2**(-a2)/(factorial(a1)*factorial(a2)), Eq(a1 + 2*a2, 2)), (0, True)) >>> marginal_distribution(ed, ed[0])(a1) Piecewise((1/factorial(a1), Eq(a1, 2)), (0, True)) References ========== .. [1] https://en.wikipedia.org/wiki/Ewens%27s_sampling_formula .. [2] http://www.stat.rutgers.edu/home/hcrane/Papers/STS529.pdf""" [end of new definitions in sympy/stats/joint_rv_types.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-16522

16,522

sympy/sympy

1.5

fb98dbb5a50dc13489b365ea6558e1efc5e62377

2019-03-31T17:55:05Z

diff --git a/sympy/combinatorics/fp_groups.py b/sympy/combinatorics/fp_groups.py index 8540e328057c..a3e9de25d22e 100644 --- a/sympy/combinatorics/fp_groups.py +++ b/sympy/combinatorics/fp_groups.py @@ -1,6 +1,7 @@ """Finitely Presented Groups and its algorithms. """ from __future__ import print_function, division +from sympy import S from sympy.combinatorics.free_groups import (FreeGroup, FreeGroupElement, free_group) from sympy.combinatorics.rewritingsystem import RewritingSystem @@ -360,7 +361,6 @@ def index(self, H, strategy="relator_based"): C = self.coset_enumeration(H, strategy) return len(C.table) - def __str__(self): if self.free_group.rank > 30: str_form = "<fp group with %s generators>" % self.free_group.rank @@ -383,7 +383,6 @@ def _to_perm_group(self): ''' from sympy.combinatorics import Permutation, PermutationGroup from sympy.combinatorics.homomorphisms import homomorphism - from sympy import S if self.order() == S.Infinity: raise NotImplementedError("Permutation presentation of infinite " "groups is not implemented") @@ -513,6 +512,21 @@ def elements(self): P, T = self._to_perm_group() return T.invert(P._elements) + @property + def is_cyclic(self): + """ + Return ``True`` if group is Cyclic. + + """ + if len(self.generators) <= 1: + return True + try: + P, T = self._to_perm_group() + except NotImplementedError: + raise NotImplementedError("Check for infinite Cyclic group " + "is not implemented") + return P.is_cyclic + class FpSubgroup(DefaultPrinting): ''' diff --git a/sympy/combinatorics/homomorphisms.py b/sympy/combinatorics/homomorphisms.py index de7b278b475c..b56ecbe069b4 100644 --- a/sympy/combinatorics/homomorphisms.py +++ b/sympy/combinatorics/homomorphisms.py @@ -353,7 +353,7 @@ def _image(r): # truth of equality otherwise success = codomain.make_confluent() s = codomain.equals(_image(r), identity) - if s in None and not success: + if s is None and not success: raise RuntimeError("Can't determine if the images " "define a homomorphism. Try increasing " "the maximum number of rewriting rules " diff --git a/sympy/combinatorics/perm_groups.py b/sympy/combinatorics/perm_groups.py index 7bbe2dd624a4..dba11c3b98a8 100644 --- a/sympy/combinatorics/perm_groups.py +++ b/sympy/combinatorics/perm_groups.py @@ -2,6 +2,7 @@ from random import randrange, choice from math import log +from sympy.ntheory import primefactors from sympy.combinatorics import Permutation from sympy.combinatorics.permutations import (_af_commutes_with, _af_invert, @@ -156,6 +157,7 @@ def __new__(cls, *args, **kwargs): obj._transitivity_degree = None obj._max_div = None obj._is_perfect = None + obj._is_cyclic = None obj._r = len(obj._generators) obj._degree = obj._generators[0].size @@ -1872,6 +1874,8 @@ def is_normal(self, gr, strict=True): d_gr = gr.degree if self.is_trivial and (d_self == d_gr or not strict): return True + if self._is_abelian: + return True new_self = self.copy() if not strict and d_self != d_gr: if d_self < d_gr: @@ -2650,6 +2654,63 @@ def order(self): self._order = m return m + def index(self, H): + """ + Returns the index of a permutation group. + + Examples + ======== + + >>> from sympy.combinatorics.permutations import Permutation + >>> from sympy.combinatorics.perm_groups import PermutationGroup + >>> a = Permutation(1,2,3) + >>> b =Permutation(3) + >>> G = PermutationGroup([a]) + >>> H = PermutationGroup([b]) + >>> G.index(H) + 3 + + """ + if H.is_subgroup(self): + return self.order()//H.order() + + @property + def is_cyclic(self): + """ + Return ``True`` if the group is Cyclic. + + Examples + ======== + + >>> from sympy.combinatorics.named_groups import AbelianGroup + >>> G = AbelianGroup(3, 4) + >>> G.is_cyclic + True + >>> G = AbelianGroup(4, 4) + >>> G.is_cyclic + False + + """ + if self._is_cyclic is not None: + return self._is_cyclic + self._is_cyclic = True + + if len(self.generators) == 1: + return True + if not self._is_abelian: + self._is_cyclic = False + return False + for p in primefactors(self.order()): + pgens = [] + for g in self.generators: + pgens.append(g**p) + if self.index(self.subgroup(pgens)) != p: + self._is_cyclic = False + return False + else: + continue + return True + def pointwise_stabilizer(self, points, incremental=True): r"""Return the pointwise stabilizer for a set of points.

diff --git a/sympy/combinatorics/tests/test_fp_groups.py b/sympy/combinatorics/tests/test_fp_groups.py index b588e229b072..36f0428922da 100644 --- a/sympy/combinatorics/tests/test_fp_groups.py +++ b/sympy/combinatorics/tests/test_fp_groups.py @@ -225,8 +225,19 @@ def test_permutation_methods(): S = FpSubgroup(G, G.derived_subgroup()) assert S.order() == 4 + def test_simplify_presentation(): # ref #16083 G = simplify_presentation(FpGroup(FreeGroup([]), [])) assert not G.generators assert not G.relators + + +def test_cyclic(): + F, x, y = free_group("x, y") + f = FpGroup(F, [x*y, x**-1*y**-1*x*y*x]) + assert f.is_cyclic + f = FpGroup(F, [x*y, x*y**-1]) + assert f.is_cyclic + f = FpGroup(F, [x**4, y**2, x*y*x**-1*y]) + assert not f.is_cyclic diff --git a/sympy/combinatorics/tests/test_perm_groups.py b/sympy/combinatorics/tests/test_perm_groups.py index bc6bd150b8a0..6a708c4d3cc8 100644 --- a/sympy/combinatorics/tests/test_perm_groups.py +++ b/sympy/combinatorics/tests/test_perm_groups.py @@ -938,3 +938,22 @@ def test_perfect(): assert G.is_perfect == False G = AlternatingGroup(5) assert G.is_perfect == True + + +def test_index(): + G = PermutationGroup(Permutation(0,1,2), Permutation(0,2,3)) + H = G.subgroup([Permutation(0,1,3)]) + assert G.index(H) == 4 + + +def test_cyclic(): + G = SymmetricGroup(2) + assert G.is_cyclic + G = AbelianGroup(3, 7) + assert G.is_cyclic + G = AbelianGroup(7, 7) + assert not G.is_cyclic + G = AlternatingGroup(3) + assert G.is_cyclic + G = AlternatingGroup(4) + assert not G.is_cyclic

[ { "components": [ { "doc": "Return ``True`` if group is Cyclic.", "lines": [ 516, 528 ], "name": "FpGroup.is_cyclic", "signature": "def is_cyclic(self):", "type": "function" } ], "file": "sympy/combinatorics/fp_groups.py" ...

[ "test_index" ]

[ "test_low_index_subgroups", "test_subgroup_presentations", "test_fp_subgroup", "test_permutation_methods", "test_simplify_presentation", "test_has", "test_generate", "test_order", "test_equality", "test_stabilizer", "test_center", "test_centralizer", "test_coset_rank", "test_coset_factor",...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added function to check if a group is Cyclic or not   #### Brief description of what is fixed or changed Added method `is_cyclic` for both `PermutationGroup` and FpGroup. Also, added a method to compute the exponent of a PermutationGroup. #### Other comments #### Release Notes   * combinatorics * added functions is_cyclic and exponent  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/combinatorics/fp_groups.py] (definition of FpGroup.is_cyclic:) def is_cyclic(self): """Return ``True`` if group is Cyclic.""" [end of new definitions in sympy/combinatorics/fp_groups.py] [start of new definitions in sympy/combinatorics/perm_groups.py] (definition of PermutationGroup.index:) def index(self, H): """Returns the index of a permutation group. Examples ======== >>> from sympy.combinatorics.permutations import Permutation >>> from sympy.combinatorics.perm_groups import PermutationGroup >>> a = Permutation(1,2,3) >>> b =Permutation(3) >>> G = PermutationGroup([a]) >>> H = PermutationGroup([b]) >>> G.index(H) 3""" (definition of PermutationGroup.is_cyclic:) def is_cyclic(self): """Return ``True`` if the group is Cyclic. Examples ======== >>> from sympy.combinatorics.named_groups import AbelianGroup >>> G = AbelianGroup(3, 4) >>> G.is_cyclic True >>> G = AbelianGroup(4, 4) >>> G.is_cyclic False""" [end of new definitions in sympy/combinatorics/perm_groups.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

scikit-learn__scikit-learn-13549

13,549

scikit-learn/scikit-learn

0.21

66cc1c7342f7f0cc0dc57fb6d56053fc46c8e5f0

2019-03-31T16:22:16Z

diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 749fa73db7458..996952602e35c 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -691,6 +691,10 @@ Support for Python 3.4 and below has been officially dropped. :mod:`sklearn.utils` .................... +- |Feature| :func:`utils.resample` now accepts a ``stratify`` parameter for + sampling according to class distributions. :issue:`13549` by :user:`Nicolas + Hug <NicolasHug>`. + - |API| Deprecated ``warn_on_dtype`` parameter from :func:`utils.check_array` and :func:`utils.check_X_y`. Added explicit warning for dtype conversion in :func:`check_pairwise_arrays` if the ``metric`` being passed is a diff --git a/sklearn/model_selection/_split.py b/sklearn/model_selection/_split.py index de8511f9922c1..17fb16ae8340e 100644 --- a/sklearn/model_selection/_split.py +++ b/sklearn/model_selection/_split.py @@ -20,6 +20,7 @@ import numpy as np from ..utils import indexable, check_random_state, safe_indexing +from ..utils import _approximate_mode from ..utils.validation import _num_samples, column_or_1d from ..utils.validation import check_array from ..utils.multiclass import type_of_target @@ -1545,75 +1546,6 @@ def split(self, X, y=None, groups=None): return super().split(X, y, groups) -def _approximate_mode(class_counts, n_draws, rng): - """Computes approximate mode of multivariate hypergeometric. - - This is an approximation to the mode of the multivariate - hypergeometric given by class_counts and n_draws. - It shouldn't be off by more than one. - - It is the mostly likely outcome of drawing n_draws many - samples from the population given by class_counts. - - Parameters - ---------- - class_counts : ndarray of int - Population per class. - n_draws : int - Number of draws (samples to draw) from the overall population. - rng : random state - Used to break ties. - - Returns - ------- - sampled_classes : ndarray of int - Number of samples drawn from each class. - np.sum(sampled_classes) == n_draws - - Examples - -------- - >>> import numpy as np - >>> from sklearn.model_selection._split import _approximate_mode - >>> _approximate_mode(class_counts=np.array([4, 2]), n_draws=3, rng=0) - array([2, 1]) - >>> _approximate_mode(class_counts=np.array([5, 2]), n_draws=4, rng=0) - array([3, 1]) - >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]), - ... n_draws=2, rng=0) - array([0, 1, 1, 0]) - >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]), - ... n_draws=2, rng=42) - array([1, 1, 0, 0]) - """ - rng = check_random_state(rng) - # this computes a bad approximation to the mode of the - # multivariate hypergeometric given by class_counts and n_draws - continuous = n_draws * class_counts / class_counts.sum() - # floored means we don't overshoot n_samples, but probably undershoot - floored = np.floor(continuous) - # we add samples according to how much "left over" probability - # they had, until we arrive at n_samples - need_to_add = int(n_draws - floored.sum()) - if need_to_add > 0: - remainder = continuous - floored - values = np.sort(np.unique(remainder))[::-1] - # add according to remainder, but break ties - # randomly to avoid biases - for value in values: - inds, = np.where(remainder == value) - # if we need_to_add less than what's in inds - # we draw randomly from them. - # if we need to add more, we add them all and - # go to the next value - add_now = min(len(inds), need_to_add) - inds = rng.choice(inds, size=add_now, replace=False) - floored[inds] += 1 - need_to_add -= add_now - if need_to_add == 0: - break - return floored.astype(np.int) - - class StratifiedShuffleSplit(BaseShuffleSplit): """Stratified ShuffleSplit cross-validator diff --git a/sklearn/utils/__init__.py b/sklearn/utils/__init__.py index 24d62640376d7..ea56498cac7c5 100644 --- a/sklearn/utils/__init__.py +++ b/sklearn/utils/__init__.py @@ -254,6 +254,10 @@ def resample(*arrays, **options): generator; If None, the random number generator is the RandomState instance used by `np.random`. + stratify : array-like or None (default=None) + If not None, data is split in a stratified fashion, using this as + the class labels. + Returns ------- resampled_arrays : sequence of indexable data-structures @@ -292,14 +296,23 @@ def resample(*arrays, **options): >>> resample(y, n_samples=2, random_state=0) array([0, 1]) + Example using stratification:: + + >>> y = [0, 0, 1, 1, 1, 1, 1, 1, 1] + >>> resample(y, n_samples=5, replace=False, stratify=y, + ... random_state=0) + [1, 1, 1, 0, 1] + See also -------- :func:`sklearn.utils.shuffle` """ + random_state = check_random_state(options.pop('random_state', None)) replace = options.pop('replace', True) max_n_samples = options.pop('n_samples', None) + stratify = options.pop('stratify', None) if options: raise ValueError("Unexpected kw arguments: %r" % options.keys()) @@ -318,12 +331,42 @@ def resample(*arrays, **options): check_consistent_length(*arrays) - if replace: - indices = random_state.randint(0, n_samples, size=(max_n_samples,)) + if stratify is None: + if replace: + indices = random_state.randint(0, n_samples, size=(max_n_samples,)) + else: + indices = np.arange(n_samples) + random_state.shuffle(indices) + indices = indices[:max_n_samples] else: - indices = np.arange(n_samples) - random_state.shuffle(indices) - indices = indices[:max_n_samples] + # Code adapted from StratifiedShuffleSplit() + y = check_array(stratify, ensure_2d=False, dtype=None) + if y.ndim == 2: + # for multi-label y, map each distinct row to a string repr + # using join because str(row) uses an ellipsis if len(row) > 1000 + y = np.array([' '.join(row.astype('str')) for row in y]) + + classes, y_indices = np.unique(y, return_inverse=True) + n_classes = classes.shape[0] + + class_counts = np.bincount(y_indices) + + # Find the sorted list of instances for each class: + # (np.unique above performs a sort, so code is O(n logn) already) + class_indices = np.split(np.argsort(y_indices, kind='mergesort'), + np.cumsum(class_counts)[:-1]) + + n_i = _approximate_mode(class_counts, max_n_samples, random_state) + + indices = [] + + for i in range(n_classes): + indices_i = random_state.choice(class_indices[i], n_i[i], + replace=replace) + indices.extend(indices_i) + + indices = random_state.permutation(indices) + # convert sparse matrices to CSR for row-based indexing arrays = [a.tocsr() if issparse(a) else a for a in arrays] @@ -694,6 +737,75 @@ def is_scalar_nan(x): return bool(isinstance(x, numbers.Real) and np.isnan(x)) +def _approximate_mode(class_counts, n_draws, rng): + """Computes approximate mode of multivariate hypergeometric. + + This is an approximation to the mode of the multivariate + hypergeometric given by class_counts and n_draws. + It shouldn't be off by more than one. + + It is the mostly likely outcome of drawing n_draws many + samples from the population given by class_counts. + + Parameters + ---------- + class_counts : ndarray of int + Population per class. + n_draws : int + Number of draws (samples to draw) from the overall population. + rng : random state + Used to break ties. + + Returns + ------- + sampled_classes : ndarray of int + Number of samples drawn from each class. + np.sum(sampled_classes) == n_draws + + Examples + -------- + >>> import numpy as np + >>> from sklearn.utils import _approximate_mode + >>> _approximate_mode(class_counts=np.array([4, 2]), n_draws=3, rng=0) + array([2, 1]) + >>> _approximate_mode(class_counts=np.array([5, 2]), n_draws=4, rng=0) + array([3, 1]) + >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]), + ... n_draws=2, rng=0) + array([0, 1, 1, 0]) + >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]), + ... n_draws=2, rng=42) + array([1, 1, 0, 0]) + """ + rng = check_random_state(rng) + # this computes a bad approximation to the mode of the + # multivariate hypergeometric given by class_counts and n_draws + continuous = n_draws * class_counts / class_counts.sum() + # floored means we don't overshoot n_samples, but probably undershoot + floored = np.floor(continuous) + # we add samples according to how much "left over" probability + # they had, until we arrive at n_samples + need_to_add = int(n_draws - floored.sum()) + if need_to_add > 0: + remainder = continuous - floored + values = np.sort(np.unique(remainder))[::-1] + # add according to remainder, but break ties + # randomly to avoid biases + for value in values: + inds, = np.where(remainder == value) + # if we need_to_add less than what's in inds + # we draw randomly from them. + # if we need to add more, we add them all and + # go to the next value + add_now = min(len(inds), need_to_add) + inds = rng.choice(inds, size=add_now, replace=False) + floored[inds] += 1 + need_to_add -= add_now + if need_to_add == 0: + break + return floored.astype(np.int) + + def check_matplotlib_support(caller_name): """Raise ImportError with detailed error message if mpl is not installed.

diff --git a/sklearn/utils/tests/test_utils.py b/sklearn/utils/tests/test_utils.py index 233d3c87efb28..f81a4830d7420 100644 --- a/sklearn/utils/tests/test_utils.py +++ b/sklearn/utils/tests/test_utils.py @@ -93,6 +93,67 @@ def test_resample(): assert_equal(len(resample([1, 2], n_samples=5)), 5) +def test_resample_stratified(): + # Make sure resample can stratify + rng = np.random.RandomState(0) + n_samples = 100 + p = .9 + X = rng.normal(size=(n_samples, 1)) + y = rng.binomial(1, p, size=n_samples) + + _, y_not_stratified = resample(X, y, n_samples=10, random_state=0, + stratify=None) + assert np.all(y_not_stratified == 1) + + _, y_stratified = resample(X, y, n_samples=10, random_state=0, stratify=y) + assert not np.all(y_stratified == 1) + assert np.sum(y_stratified) == 9 # all 1s, one 0 + + +def test_resample_stratified_replace(): + # Make sure stratified resampling supports the replace parameter + rng = np.random.RandomState(0) + n_samples = 100 + X = rng.normal(size=(n_samples, 1)) + y = rng.randint(0, 2, size=n_samples) + + X_replace, _ = resample(X, y, replace=True, n_samples=50, + random_state=rng, stratify=y) + X_no_replace, _ = resample(X, y, replace=False, n_samples=50, + random_state=rng, stratify=y) + assert np.unique(X_replace).shape[0] < 50 + assert np.unique(X_no_replace).shape[0] == 50 + + # make sure n_samples can be greater than X.shape[0] if we sample with + # replacement + X_replace, _ = resample(X, y, replace=True, n_samples=1000, + random_state=rng, stratify=y) + assert X_replace.shape[0] == 1000 + assert np.unique(X_replace).shape[0] == 100 + + +def test_resample_stratify_2dy(): + # Make sure y can be 2d when stratifying + rng = np.random.RandomState(0) + n_samples = 100 + X = rng.normal(size=(n_samples, 1)) + y = rng.randint(0, 2, size=(n_samples, 2)) + X, y = resample(X, y, n_samples=50, random_state=rng, stratify=y) + assert y.ndim == 2 + + +def test_resample_stratify_sparse_error(): + # resample must be ndarray + rng = np.random.RandomState(0) + n_samples = 100 + X = rng.normal(size=(n_samples, 2)) + y = rng.randint(0, 2, size=n_samples) + stratify = sp.csr_matrix(y) + with pytest.raises(TypeError, match='A sparse matrix was passed'): + X, y = resample(X, y, n_samples=50, random_state=rng, + stratify=stratify) + + def test_safe_mask(): random_state = check_random_state(0) X = random_state.rand(5, 4)

diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 749fa73db7458..996952602e35c 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -691,6 +691,10 @@ Support for Python 3.4 and below has been officially dropped. :mod:`sklearn.utils` .................... +- |Feature| :func:`utils.resample` now accepts a ``stratify`` parameter for + sampling according to class distributions. :issue:`13549` by :user:`Nicolas + Hug <NicolasHug>`. + - |API| Deprecated ``warn_on_dtype`` parameter from :func:`utils.check_array` and :func:`utils.check_X_y`. Added explicit warning for dtype conversion in :func:`check_pairwise_arrays` if the ``metric`` being passed is a

[ { "components": [ { "doc": "Computes approximate mode of multivariate hypergeometric.\n\nThis is an approximation to the mode of the multivariate\nhypergeometric given by class_counts and n_draws.\nIt shouldn't be off by more than one.\n\nIt is the mostly likely outcome of drawing n_draws many\nsa...

[ "sklearn/utils/tests/test_utils.py::test_resample_stratified", "sklearn/utils/tests/test_utils.py::test_resample_stratified_replace", "sklearn/utils/tests/test_utils.py::test_resample_stratify_2dy", "sklearn/utils/tests/test_utils.py::test_resample_stratify_sparse_error" ]

[ "sklearn/utils/tests/test_utils.py::test_make_rng", "sklearn/utils/tests/test_utils.py::test_deprecated", "sklearn/utils/tests/test_utils.py::test_resample", "sklearn/utils/tests/test_utils.py::test_safe_mask", "sklearn/utils/tests/test_utils.py::test_column_or_1d", "sklearn/utils/tests/test_utils.py::tes...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG] Add a stratify option to utils.resample  #### Reference Issues/PRs  Closes #13507 #### What does this implement/fix? Explain your changes. This PR adds a `stratify` option to `utils.resample`. The issue with `train_test_split` is that it will (rightfully) complain if train or testsets are empty. The code is based on that of `StratifiedShuffleSplit`. #### Any other comments? I personally need this to properly implement SuccessiveHalving #12538  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/utils/__init__.py] (definition of _approximate_mode:) def _approximate_mode(class_counts, n_draws, rng): """Computes approximate mode of multivariate hypergeometric. This is an approximation to the mode of the multivariate hypergeometric given by class_counts and n_draws. It shouldn't be off by more than one. It is the mostly likely outcome of drawing n_draws many samples from the population given by class_counts. Parameters ---------- class_counts : ndarray of int Population per class. n_draws : int Number of draws (samples to draw) from the overall population. rng : random state Used to break ties. Returns ------- sampled_classes : ndarray of int Number of samples drawn from each class. np.sum(sampled_classes) == n_draws Examples -------- >>> import numpy as np >>> from sklearn.utils import _approximate_mode >>> _approximate_mode(class_counts=np.array([4, 2]), n_draws=3, rng=0) array([2, 1]) >>> _approximate_mode(class_counts=np.array([5, 2]), n_draws=4, rng=0) array([3, 1]) >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]), ... n_draws=2, rng=0) array([0, 1, 1, 0]) >>> _approximate_mode(class_counts=np.array([2, 2, 2, 1]), ... n_draws=2, rng=42) array([1, 1, 0, 0])""" [end of new definitions in sklearn/utils/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Stratified subsampler utility? I have some data `X` and `y` that I want to subsample (i.e. only keep a subset of the samples) in a stratified way. Using something like ```py _, X_sub, _, y_sub = train_test_split( X, y, stratify=stratify, train_size=None, test_size=n_samples_sub) ``` is almost what I need. But that will error if: - I happen to want exactly `X.shape[0]` samples (`ValueError: test_size=60 should be either positive and smaller than the number of samples`) - I want something close to `X.shape[0]` which is not enough to have a stratified test or train set (`ValueError: The train_size = 1 should be greater or equal to the number of classes = 2`) ---- ~~Would it make sense to add a `subsample()` util? Another option would be to add a `bypass_checks` to `train_test_split`~~ Basically what I need is a `stratify` option to `utils.resample`, that's probably the most appropriate place to introduce this. ---------- -------------------- </issues>

66cc1c7342f7f0cc0dc57fb6d56053fc46c8e5f0

sympy__sympy-16516

16,516

sympy/sympy

1.5

fb98dbb5a50dc13489b365ea6558e1efc5e62377

2019-03-31T13:46:58Z

diff --git a/doc/src/modules/crypto.rst b/doc/src/modules/crypto.rst index f7808fa8f588..2cce9f948563 100644 --- a/doc/src/modules/crypto.rst +++ b/doc/src/modules/crypto.rst @@ -50,10 +50,18 @@ substitutions at different times in the message. .. autofunction:: decipher_shift +.. autofunction:: encipher_rot13 + +.. autofunction:: decipher_rot13 + .. autofunction:: encipher_affine .. autofunction:: decipher_affine +.. autofunction:: encipher_atbash + +.. autofunction:: decipher_atbash + .. autofunction:: encipher_substitution .. autofunction:: encipher_vigenere diff --git a/sympy/crypto/__init__.py b/sympy/crypto/__init__.py index 58ffb98e59e0..0ba69df2379f 100644 --- a/sympy/crypto/__init__.py +++ b/sympy/crypto/__init__.py @@ -11,4 +11,5 @@ encipher_elgamal, dh_private_key, dh_public_key, dh_shared_key, padded_key, encipher_bifid, decipher_bifid, bifid_square, bifid5, bifid6, bifid10, decipher_gm, encipher_gm, gm_public_key, - gm_private_key, bg_private_key, bg_public_key, encipher_bg, decipher_bg) + gm_private_key, bg_private_key, bg_public_key, encipher_bg, decipher_bg, + encipher_rot13, decipher_rot13, encipher_atbash, decipher_atbash) diff --git a/sympy/crypto/crypto.py b/sympy/crypto/crypto.py index db5937ef2097..85e582c9bfee 100644 --- a/sympy/crypto/crypto.py +++ b/sympy/crypto/crypto.py @@ -259,6 +259,55 @@ def decipher_shift(msg, key, symbols=None): """ return encipher_shift(msg, -key, symbols) +def encipher_rot13(msg, symbols=None): + """ + Performs the ROT13 encryption on a given plaintext ```msg```. + + Notes + ===== + + ROT13 is a substitution cipher which substitutes each letter + in the plaintext message for the letter furthest away from it + in the English alphabet. + + Equivalently, it is just a Caeser (shift) cipher with a shift + key of 13 (midway point of the alphabet). + + See Also + ======== + + decipher_rot13 + """ + return encipher_shift(msg, 13, symbols) + +def decipher_rot13(msg, symbols=None): + """ + Performs the ROT13 decryption on a given plaintext ```msg```. + + Notes + ===== + + ```decipher_rot13``` is equivalent to ```encipher_rot13``` as both + ```decipher_shift``` with a key of 13 and ```encipher_shift``` key with a + key of 13 will return the same results. Nonetheless, + ```decipher_rot13``` has nonetheless been explicitly defined here for + consistency. + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_rot13, decipher_rot13 + >>> msg = 'GONAVYBEATARMY' + >>> ciphertext = encipher_rot13(msg);ciphertext + 'TBANILORNGNEZL' + >>> decipher_rot13(ciphertext) + 'GONAVYBEATARMY' + >>> encipher_rot13(msg) == decipher_rot13(msg) + True + >>> msg == decipher_rot13(ciphertext) + True + """ + return decipher_shift(msg, 13, symbols) ######## affine cipher examples ############ @@ -349,6 +398,53 @@ def decipher_affine(msg, key, symbols=None): """ return encipher_affine(msg, key, symbols, _inverse=True) +def encipher_atbash(msg, symbols=None): + r""" + Enciphers a given ```msg``` into its Atbash ciphertext and returns it. + + Notes + ===== + + Atbash is a substitution cipher originally used to encrypt the Hebrew + alphabet. Atbash works on the principle of mapping each alphabet to its + reverse / counterpart (i.e. a would map to z, b to y etc.) + + Atbash is functionally equivalent to the affine cipher with ```a = 25``` + and ```b = 25``` + + See Also + ======== + + decipher_atbash + """ + return encipher_affine(msg, (25,25), symbols) + +def decipher_atbash(msg, symbols=None): + r""" + Deciphers a given ```msg``` using Atbash cipher and returns it. + + Notes + ===== + + ```decipher_atbash``` is functionally equivalent to ```encipher_atbash```. + However, it has still been added as a separate function to maintain + consistency. + + Examples + ======== + + >>> from sympy.crypto.crypto import encipher_atbash, decipher_atbash + >>> msg = 'GONAVYBEATARMY' + >>> encipher_atbash(msg) + 'TLMZEBYVZGZINB' + >>> decipher_atbash(msg) + 'TLMZEBYVZGZINB' + >>> encipher_atbash(msg) == decipher_atbash(msg) + True + >>> msg == encipher_atbash(encipher_atbash(msg)) + True + """ + return decipher_affine(msg, (25,25), symbols) #################### substitution cipher ###########################

diff --git a/sympy/crypto/tests/test_crypto.py b/sympy/crypto/tests/test_crypto.py index e65f8182829a..f999cbf76fc8 100644 --- a/sympy/crypto/tests/test_crypto.py +++ b/sympy/crypto/tests/test_crypto.py @@ -14,7 +14,8 @@ dh_shared_key, decipher_shift, decipher_affine, encipher_bifid, decipher_bifid, bifid_square, padded_key, uniq, decipher_gm, encipher_gm, gm_public_key, gm_private_key, encipher_bg, decipher_bg, - bg_private_key, bg_public_key) + bg_private_key, bg_public_key, encipher_rot13, decipher_rot13, + encipher_atbash, decipher_atbash) from sympy.matrices import Matrix from sympy.ntheory import isprime, is_primitive_root from sympy.polys.domains import FF @@ -37,6 +38,12 @@ def test_encipher_shift(): assert encipher_shift("ABC", -1) == "ZAB" assert decipher_shift("ZAB", -1) == "ABC" +def test_encipher_rot13(): + assert encipher_rot13("ABC") == "NOP" + assert encipher_rot13("NOP") == "ABC" + assert decipher_rot13("ABC") == "NOP" + assert decipher_rot13("NOP") == "ABC" + def test_encipher_affine(): assert encipher_affine("ABC", (1, 0)) == "ABC" @@ -47,6 +54,11 @@ def test_encipher_affine(): assert encipher_affine("ABC", (3, 16)) == "QTW" assert decipher_affine("QTW", (3, 16)) == "ABC" +def test_encipher_atbash(): + assert encipher_atbash("ABC") == "ZYX" + assert encipher_atbash("ZYX") == "ABC" + assert decipher_atbash("ABC") == "ZYX" + assert decipher_atbash("ZYX") == "ABC" def test_encipher_substitution(): assert encipher_substitution("ABC", "BAC", "ABC") == "BAC"

diff --git a/doc/src/modules/crypto.rst b/doc/src/modules/crypto.rst index f7808fa8f588..2cce9f948563 100644 --- a/doc/src/modules/crypto.rst +++ b/doc/src/modules/crypto.rst @@ -50,10 +50,18 @@ substitutions at different times in the message. .. autofunction:: decipher_shift +.. autofunction:: encipher_rot13 + +.. autofunction:: decipher_rot13 + .. autofunction:: encipher_affine .. autofunction:: decipher_affine +.. autofunction:: encipher_atbash + +.. autofunction:: decipher_atbash + .. autofunction:: encipher_substitution .. autofunction:: encipher_vigenere

[ { "components": [ { "doc": "Performs the ROT13 encryption on a given plaintext ```msg```.\n\nNotes\n=====\n\nROT13 is a substitution cipher which substitutes each letter\nin the plaintext message for the letter furthest away from it\nin the English alphabet.\n\nEquivalently, it is just a Caeser (s...

[ "test_cycle_list", "test_encipher_shift", "test_encipher_rot13", "test_encipher_affine", "test_encipher_atbash", "test_encipher_substitution", "test_check_and_join", "test_encipher_vigenere", "test_decipher_vigenere", "test_encipher_hill", "test_decipher_hill", "test_encipher_bifid5", "test_...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added ROT13 and Atbash to sympy.crypto  #### References to other Issues or PRs  Fixes #16495 #### Brief description of what is fixed or changed - Added ```encipher_rot13``` , ```decipher_rot13``` - Added ```encipher_atbash```, ```decipher_atbash``` - Updated tests and documentation for both. #### Other comments - Both encipher and decipher do the same thing, in theory. However I made them different functions because they are intended for different uses even though they are functionally equivalent, and would also maintain code quality and prevent ambiguity in future. #### Release Notes   * crypto * added ```rot13``` and ```atbash``` ciphers  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/crypto/crypto.py] (definition of encipher_rot13:) def encipher_rot13(msg, symbols=None): """Performs the ROT13 encryption on a given plaintext ```msg```. Notes ===== ROT13 is a substitution cipher which substitutes each letter in the plaintext message for the letter furthest away from it in the English alphabet. Equivalently, it is just a Caeser (shift) cipher with a shift key of 13 (midway point of the alphabet). See Also ======== decipher_rot13""" (definition of decipher_rot13:) def decipher_rot13(msg, symbols=None): """Performs the ROT13 decryption on a given plaintext ```msg```. Notes ===== ```decipher_rot13``` is equivalent to ```encipher_rot13``` as both ```decipher_shift``` with a key of 13 and ```encipher_shift``` key with a key of 13 will return the same results. Nonetheless, ```decipher_rot13``` has nonetheless been explicitly defined here for consistency. Examples ======== >>> from sympy.crypto.crypto import encipher_rot13, decipher_rot13 >>> msg = 'GONAVYBEATARMY' >>> ciphertext = encipher_rot13(msg);ciphertext 'TBANILORNGNEZL' >>> decipher_rot13(ciphertext) 'GONAVYBEATARMY' >>> encipher_rot13(msg) == decipher_rot13(msg) True >>> msg == decipher_rot13(ciphertext) True""" (definition of encipher_atbash:) def encipher_atbash(msg, symbols=None): """Enciphers a given ```msg``` into its Atbash ciphertext and returns it. Notes ===== Atbash is a substitution cipher originally used to encrypt the Hebrew alphabet. Atbash works on the principle of mapping each alphabet to its reverse / counterpart (i.e. a would map to z, b to y etc.) Atbash is functionally equivalent to the affine cipher with ```a = 25``` and ```b = 25``` See Also ======== decipher_atbash""" (definition of decipher_atbash:) def decipher_atbash(msg, symbols=None): """Deciphers a given ```msg``` using Atbash cipher and returns it. Notes ===== ```decipher_atbash``` is functionally equivalent to ```encipher_atbash```. However, it has still been added as a separate function to maintain consistency. Examples ======== >>> from sympy.crypto.crypto import encipher_atbash, decipher_atbash >>> msg = 'GONAVYBEATARMY' >>> encipher_atbash(msg) 'TLMZEBYVZGZINB' >>> decipher_atbash(msg) 'TLMZEBYVZGZINB' >>> encipher_atbash(msg) == decipher_atbash(msg) True >>> msg == encipher_atbash(encipher_atbash(msg)) True""" [end of new definitions in sympy/crypto/crypto.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Implementing classical ciphers as special cases of already existing ciphers in crypto.py The file ```/sympy/crypto/crypto.py``` contains implementations of various classical ciphers. Extending this file to include certain other classical ciphers which are derivatives of the ones already present in the file would be useful. Such implementations would be just a couple of lines code (excluding comments explaining the working) for each as most of the ```encipher_``` functions which are required already exist. Examples of possible extensions are : [ROT13](https://en.wikipedia.org/wiki/ROT13) as an extension of ```encipher_shift()``` (and ```decipher_shift()``` likewise) [Atbash](https://en.wikipedia.org/wiki/Atbash) as an extension of ```encipher_affine()``` (and ```decipher_affine()``` likewise) If possible and if this issue is relevant, I would like to be assigned this issue and work on it and extending the ```crypto.py``` file further. ---------- @asmeurer is it okay for me to start work on this and submit a PR? -------------------- </issues>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-16452

16,452

sympy/sympy

1.5

4cdcbd914d66733eee1de77d592bbad3d693b049

2019-03-26T19:55:39Z

diff --git a/sympy/geometry/point.py b/sympy/geometry/point.py index 7630b517cef6..6a061ec78c5b 100644 --- a/sympy/geometry/point.py +++ b/sympy/geometry/point.py @@ -152,7 +152,7 @@ def __new__(cls, *args, **kwargs): raise ValueError(filldedent(''' on_morph value should be 'error', 'warn' or 'ignore'.''')) - if any(i for i in coords[dim:]): + if any(coords[dim:]): raise ValueError('Nonzero coordinates cannot be removed.') if any(a.is_number and im(a) for a in coords): raise ValueError('Imaginary coordinates are not permitted.') diff --git a/sympy/matrices/__init__.py b/sympy/matrices/__init__.py index c23ac27831a8..196951ac88a2 100644 --- a/sympy/matrices/__init__.py +++ b/sympy/matrices/__init__.py @@ -15,6 +15,7 @@ Matrix = MutableMatrix = MutableDenseMatrix from .sparse import MutableSparseMatrix +from .sparsetools import banded from .immutable import ImmutableDenseMatrix, ImmutableSparseMatrix ImmutableMatrix = ImmutableDenseMatrix diff --git a/sympy/matrices/common.py b/sympy/matrices/common.py index 832115f4f54d..721173d4ec06 100644 --- a/sympy/matrices/common.py +++ b/sympy/matrices/common.py @@ -750,8 +750,9 @@ def diag(kls, *args, **kwargs): [3, 0, 0], [0, 4, 5]]) - Elements within a list need not all be of the same length unless - `strict` is set to True: + When `unpack` is False, elements within a list need not all be + of the same length. Setting `strict` to True would raise a + ValueError for the following: >>> Matrix.diag([[1, 2, 3], [4, 5], [6]], unpack=False) Matrix([ @@ -779,6 +780,7 @@ def diag(kls, *args, **kwargs): """ from sympy.matrices.matrices import MatrixBase from sympy.matrices.dense import Matrix + from sympy.matrices.sparse import SparseMatrix klass = kwargs.get('cls', kls) strict = kwargs.get('strict', False) # lists -> Matrices unpack = kwargs.get('unpack', True) # unpack single sequence @@ -788,49 +790,47 @@ def diag(kls, *args, **kwargs): # fill a default dict with the diagonal entries diag_entries = defaultdict(int) - R = C = 0 # keep track of the biggest index seen + rmax = cmax = 0 # keep track of the biggest index seen for m in args: - if hasattr(m, 'rows') or isinstance(m, list): - # in this case, we're a matrix or list - if hasattr(m, 'rows'): - # convert to list of lists - r, c = m.shape - m = m.tolist() + if isinstance(m, list): + if strict: + # if malformed, Matrix will raise an error + _ = Matrix(m) + r, c = _.shape + m = _.tolist() else: - # make sure all list elements are lists - r = len(m) - if strict: - # let Matrix raise the error - m = Matrix(m) - c = m.cols - m = m.tolist() - else: - m = [mi if isinstance(mi, list) else [mi] - for mi in m] - c = max(map(len, m)) - # process list of lists - for i in range(len(m)): - for j, mij in enumerate(m[i]): - diag_entries[(i + R, j + C)] = mij - R += r - C += c - else: - # in this case, we're a single value - diag_entries[(R, C)] = m - R += 1 - C += 1 + m = SparseMatrix(m) + for (i, j), _ in m._smat.items(): + diag_entries[(i + rmax, j + cmax)] = _ + r, c = m.shape + m = [] # to skip process below + elif hasattr(m, 'shape'): # a Matrix + # convert to list of lists + r, c = m.shape + m = m.tolist() + else: # in this case, we're a single value + diag_entries[(rmax, cmax)] = m + rmax += 1 + cmax += 1 + continue + # process list of lists + for i in range(len(m)): + for j, _ in enumerate(m[i]): + diag_entries[(i + rmax, j + cmax)] = _ + rmax += r + cmax += c rows = kwargs.get('rows', None) cols = kwargs.get('cols', None) if rows is None: rows, cols = cols, rows if rows is None: - rows, cols = R, C + rows, cols = rmax, cmax else: cols = rows if cols is None else cols - if rows < R or cols < C: + if rows < rmax or cols < cmax: raise ValueError(filldedent(''' The constructed matrix is {} x {} but a size of {} x {} - was specified.'''.format(R, C, rows, cols))) + was specified.'''.format(rmax, cmax, rows, cols))) return klass._eval_diag(rows, cols, diag_entries) @classmethod diff --git a/sympy/matrices/sparse.py b/sympy/matrices/sparse.py index 176f7e963066..12c554906ef0 100644 --- a/sympy/matrices/sparse.py +++ b/sympy/matrices/sparse.py @@ -133,7 +133,7 @@ def __new__(cls, *args, **kwargs): value = self._sympify( op(self._sympify(i), self._sympify(j))) if value: - self._smat[(i, j)] = value + self._smat[i, j] = value elif isinstance(args[2], (dict, Dict)): def update(i, j, v): # update self._smat and make sure there are @@ -193,7 +193,7 @@ def update(i, j, v): row = [row] for j, vij in enumerate(row): if vij: - self._smat[(i, j)] = self._sympify(vij) + self._smat[i, j] = self._sympify(vij) c = max(c, len(row)) self.rows = len(v) if c else 0 self.cols = c @@ -206,7 +206,7 @@ def update(i, j, v): for j in range(self.cols): value = _list[self.cols*i + j] if value: - self._smat[(i, j)] = value + self._smat[i, j] = value return self def __eq__(self, other): @@ -397,11 +397,11 @@ def _eval_col_insert(self, icol, other): row, col = key if col >= icol: col += other.cols - new_smat[(row, col)] = val + new_smat[row, col] = val # add other's keys for key, val in other._smat.items(): row, col = key - new_smat[(row, col + icol)] = val + new_smat[row, col + icol] = val return self._new(self.rows, self.cols + other.cols, new_smat) def _eval_conjugate(self): @@ -422,7 +422,7 @@ def _eval_extract(self, rowsList, colsList): # keeping only the ones that are desired for rk, ck in self._smat: if rk in urow and ck in ucol: - smat[(urow.index(rk), ucol.index(ck))] = self._smat[(rk, ck)] + smat[urow.index(rk), ucol.index(ck)] = self._smat[rk, ck] rv = self._new(len(urow), len(ucol), smat) # rv is nominally correct but there might be rows/cols @@ -484,7 +484,7 @@ def _eval_matrix_mul(self, other): indices = set(col_lookup[col].keys()) & set(row_lookup[row].keys()) if indices: val = sum(row_lookup[row][k]*col_lookup[col][k] for k in indices) - smat[(row, col)] = val + smat[row, col] = val return self._new(self.rows, other.cols, smat) def _eval_row_insert(self, irow, other): @@ -496,11 +496,11 @@ def _eval_row_insert(self, irow, other): row, col = key if row >= irow: row += other.rows - new_smat[(row, col)] = val + new_smat[row, col] = val # add other's keys for key, val in other._smat.items(): row, col = key - new_smat[(row + irow, col)] = val + new_smat[row + irow, col] = val return self._new(self.rows + other.rows, self.cols, new_smat) def _eval_scalar_mul(self, other): @@ -1022,9 +1022,9 @@ def __setitem__(self, key, value): if rv is not None: i, j, value = rv if value: - self._smat[(i, j)] = value + self._smat[i, j] = value elif (i, j) in self._smat: - del self._smat[(i, j)] + del self._smat[i, j] def as_mutable(self): return self.copy() @@ -1120,7 +1120,7 @@ def col_join(self, other): for j in range(B.cols): v = b[k] if v: - A._smat[(i + A.rows, j)] = v + A._smat[i + A.rows, j] = v k += 1 else: for (i, j), v in B._smat.items(): @@ -1148,7 +1148,7 @@ def col_op(self, j, f): v = self._smat.get((i, j), S.Zero) fv = f(v, i) if fv: - self._smat[(i, j)] = fv + self._smat[i, j] = fv elif v: self._smat.pop((i, j)) @@ -1328,11 +1328,11 @@ def row_join(self, other): for j in range(B.cols): v = b[k] if v: - A._smat[(i, j + A.cols)] = v + A._smat[i, j + A.cols] = v k += 1 else: for (i, j), v in B._smat.items(): - A._smat[(i, j + A.cols)] = v + A._smat[i, j + A.cols] = v A.cols += B.cols return A @@ -1363,7 +1363,7 @@ def row_op(self, i, f): v = self._smat.get((i, j), S.Zero) fv = f(v, j) if fv: - self._smat[(i, j)] = fv + self._smat[i, j] = fv elif v: self._smat.pop((i, j)) diff --git a/sympy/matrices/sparsetools.py b/sympy/matrices/sparsetools.py index 4089094bec56..fcb218b2361e 100644 --- a/sympy/matrices/sparsetools.py +++ b/sympy/matrices/sparsetools.py @@ -1,6 +1,8 @@ from __future__ import division, print_function -from sympy.core.compatibility import range +from sympy.core.compatibility import range, as_int +from sympy.utilities.iterables import is_sequence +from sympy.utilities.misc import filldedent from .sparse import SparseMatrix @@ -36,3 +38,237 @@ def _csrtodok(csr): for l, m in zip(A[indices], JA[indices]): smat[i, m] = l return SparseMatrix(*(shape + [smat])) + + +def banded(*args, **kwargs): + """Returns a SparseMatrix from the given dictionary describing + the diagonals of the matrix. The keys are positive for upper + diagonals and negative for those below the main diagonal. The + values may be: + * expressions or single-argument functions, + * lists or tuples of values, + * matrices + Unless dimensions are given, the size of the returned matrix will + be large enough to contain the largest non-zero value provided. + + kwargs + ====== + + rows : rows of the resulting matrix; computed if + not given. + + cols : columns of the resulting matrix; computed if + not given. + + Examples + ======== + + >>> from sympy import banded, ones, Matrix + >>> from sympy.abc import x + + If explicit values are given in tuples, + the matrix will autosize to contain all values, otherwise + a single value is filled onto the entire diagonal: + + >>> banded({1: (1, 2, 3), -1: (4, 5, 6), 0: x}) + Matrix([ + [x, 1, 0, 0], + [4, x, 2, 0], + [0, 5, x, 3], + [0, 0, 6, x]]) + + A function accepting a single argument can be used to fill the + diagonal as a function of diagonal index (which starts at 0). + The size (or shape) of the matrix must be given to obtain more + than a 1x1 matrix: + + >>> s = lambda d: (1 + d)**2 + >>> banded(5, {0: s, 2: s, -2: 2}) + Matrix([ + [1, 0, 1, 0, 0], + [0, 4, 0, 4, 0], + [2, 0, 9, 0, 9], + [0, 2, 0, 16, 0], + [0, 0, 2, 0, 25]]) + + The diagonal of matrices placed on a diagonal will coincide + with the indicated diagonal: + + >>> vert = Matrix([1, 2, 3]) + >>> banded({0: vert}, cols=3) + Matrix([ + [1, 0, 0], + [2, 1, 0], + [3, 2, 1], + [0, 3, 2], + [0, 0, 3]]) + + >>> banded(4, {0: ones(2)}) + Matrix([ + [1, 1, 0, 0], + [1, 1, 0, 0], + [0, 0, 1, 1], + [0, 0, 1, 1]]) + + Errors are raised if the designated size will not hold + all values an integral number of times. Here, the rows + are designated as odd (but an even number is required to + hold the off-diagonal 2x2 ones): + + >>> banded({0: 2, 1: ones(2)}, rows=5) + Traceback (most recent call last): + ... + ValueError: + sequence does not fit an integral number of times in the matrix + + And here, an even number of rows is given...but the square + matrix has an even number of columns, too. As we saw + in the previous example, an odd number is required: + + >>> banded(4, {0: 2, 1: ones(2)}) # trying to make 4x4 and cols must be odd + Traceback (most recent call last): + ... + ValueError: + sequence does not fit an integral number of times in the matrix + + A way around having to count rows is to enclosing matrix elements + in a tuple and indicate the desired number of them to the right: + + >>> banded({0: 2, 2: (ones(2),)*3}) + Matrix([ + [2, 0, 1, 1, 0, 0, 0, 0], + [0, 2, 1, 1, 0, 0, 0, 0], + [0, 0, 2, 0, 1, 1, 0, 0], + [0, 0, 0, 2, 1, 1, 0, 0], + [0, 0, 0, 0, 2, 0, 1, 1], + [0, 0, 0, 0, 0, 2, 1, 1]]) + + An error will be raised if more than one value + is written to a given entry. Here, the ones overlap + with the main diagonal if they are placed on the + first diagonal: + + >>> banded({0: (2,)*5, 1: (ones(2),)*3}) + Traceback (most recent call last): + ... + ValueError: collision at (1, 1) + + By placing a 0 at the bottom left of the 2x2 matrix of + ones, the collision is avoided: + + >>> u2 = Matrix([ + ... [1, 1], + ... [0, 1]]) + >>> banded({0: [2]*5, 1: [u2]*3}) + Matrix([ + [2, 1, 1, 0, 0, 0, 0], + [0, 2, 1, 0, 0, 0, 0], + [0, 0, 2, 1, 1, 0, 0], + [0, 0, 0, 2, 1, 0, 0], + [0, 0, 0, 0, 2, 1, 1], + [0, 0, 0, 0, 0, 0, 1]]) + """ + from sympy import Dict, Dummy, SparseMatrix + try: + if len(args) not in (1, 2, 3): + raise TypeError + if not isinstance(args[-1], (dict, Dict)): + raise TypeError + if len(args) == 1: + rows = kwargs.get('rows', None) + cols = kwargs.get('cols', None) + if rows is not None: + rows = as_int(rows) + if cols is not None: + cols = as_int(cols) + elif len(args) == 2: + rows = cols = as_int(args[0]) + else: + rows, cols = map(as_int, args[:2]) + # fails with ValueError if any keys are not ints + _ = all(as_int(k) for k in args[-1]) + except (ValueError, TypeError): + raise TypeError(filldedent( + '''unrecognized input to banded: + expecting [[row,] col,] {int: value}''')) + def rc(d): + # return row,col coord of diagonal start + r = -d if d < 0 else 0 + c = 0 if r else d + return r, c + smat = {} + undone = [] + tba = Dummy() + # first handle objects with size + for d, v in args[-1].items(): + r, c = rc(d) + # note: only list and tuple are recognized since this + # will allow other Basic objects like Tuple + # into the matrix if so desired + if isinstance(v, (list, tuple)): + extra = 0 + for i, vi in enumerate(v): + i += extra + if is_sequence(vi): + vi = SparseMatrix(vi) + smat[r + i, c + i] = vi + extra += min(vi.shape) - 1 + else: + smat[r + i, c + i] = vi + elif is_sequence(v): + v = SparseMatrix(v) + rv, cv = v.shape + if rows and cols: + nr, xr = divmod(rows - r, rv) + nc, xc = divmod(cols - c, cv) + x = xr or xc + do = min(nr, nc) + elif rows: + do, x = divmod(rows - r, rv) + elif cols: + do, x = divmod(cols - c, cv) + else: + do = 1 + x = 0 + if x: + raise ValueError(filldedent(''' + sequence does not fit an integral number of times + in the matrix''')) + j = min(v.shape) + for i in range(do): + smat[r, c] = v + r += j + c += j + elif v: + smat[r, c] = tba + undone.append((d, v)) + s = SparseMatrix(None, smat) # to expand matrices + smat = s._smat + # check for dim errors here + if rows is not None and rows < s.rows: + raise ValueError('Designated rows %s < needed %s' % (rows, s.rows)) + if cols is not None and cols < s.cols: + raise ValueError('Designated cols %s < needed %s' % (cols, s.cols)) + if rows is cols is None: + rows = s.rows + cols = s.cols + elif rows is not None and cols is None: + cols = max(rows, s.cols) + elif cols is not None and rows is None: + rows = max(cols, s.rows) + def update(i, j, v): + # update smat and make sure there are + # no collisions + if v: + if (i, j) in smat and smat[i, j] not in (tba, v): + raise ValueError('collision at %s' % ((i, j),)) + smat[i, j] = v + if undone: + for d, vi in undone: + r, c = rc(d) + v = vi if callable(vi) else lambda _: vi + i = 0 + while r + i < rows and c + i < cols: + update(r + i, c + i, v(i)) + i += 1 + return SparseMatrix(rows, cols, smat) diff --git a/sympy/polys/polytools.py b/sympy/polys/polytools.py index f4ef829b03eb..418ac6e5aad0 100644 --- a/sympy/polys/polytools.py +++ b/sympy/polys/polytools.py @@ -635,7 +635,7 @@ def ltrim(f, gen): for monom, coeff in rep.items(): - if any(i for i in monom[:j]): + if any(monom[:j]): # some generator is used in the portion to be trimmed raise PolynomialError("can't left trim %s" % f) diff --git a/sympy/solvers/ode.py b/sympy/solvers/ode.py index 21ddc9e40e5a..afc138caa71b 100644 --- a/sympy/solvers/ode.py +++ b/sympy/solvers/ode.py @@ -6284,7 +6284,7 @@ def lie_heuristic_bivariate(match, comp=False): soldict = solve(polyy.values(), *symset) if isinstance(soldict, list): soldict = soldict[0] - if any(x for x in soldict.values()): + if any(soldict.values()): xired = xieq.subs(soldict) etared = etaeq.subs(soldict) # Scaling is done by substituting one for the parameters @@ -6351,7 +6351,7 @@ def lie_heuristic_chi(match, comp=False): soldict = solve(cpoly.values(), *solsyms) if isinstance(soldict, list): soldict = soldict[0] - if any(x for x in soldict.values()): + if any(soldict.values()): chieq = chieq.subs(soldict) dict_ = dict((sym, 1) for sym in solsyms) chieq = chieq.subs(dict_) diff --git a/sympy/solvers/polysys.py b/sympy/solvers/polysys.py index 004fdb2fa875..aa22a1df93f9 100644 --- a/sympy/solvers/polysys.py +++ b/sympy/solvers/polysys.py @@ -162,7 +162,7 @@ def solve_generic(polys, opt): def _is_univariate(f): """Returns True if 'f' is univariate in its last variable. """ for monom in f.monoms(): - if any(m for m in monom[:-1]): + if any(monom[:-1]): return False return True

diff --git a/sympy/matrices/tests/test_commonmatrix.py b/sympy/matrices/tests/test_commonmatrix.py index f71501f1216e..8daa32508411 100644 --- a/sympy/matrices/tests/test_commonmatrix.py +++ b/sympy/matrices/tests/test_commonmatrix.py @@ -308,7 +308,7 @@ def test_vstack(): # PropertiesOnlyMatrix tests def test_atoms(): m = PropertiesOnlyMatrix(2, 2, [1, 2, x, 1 - 1/x]) - assert m.atoms() == {S(1),S(2),S(-1), x} + assert m.atoms() == {S(1), S(2), S(-1), x} assert m.atoms(Symbol) == {x} @@ -423,8 +423,8 @@ def test_is_lower(): def test_is_square(): - m = PropertiesOnlyMatrix([[1],[1]]) - m2 = PropertiesOnlyMatrix([[2,2],[2,2]]) + m = PropertiesOnlyMatrix([[1], [1]]) + m2 = PropertiesOnlyMatrix([[2, 2], [2, 2]]) assert not m.is_square assert m2.is_square @@ -461,9 +461,11 @@ def test_is_zero(): def test_values(): - assert set(PropertiesOnlyMatrix(2,2,[0,1,2,3]).values()) == set([1,2,3]) + assert set(PropertiesOnlyMatrix(2, 2, [0, 1, 2, 3] + ).values()) == set([1, 2, 3]) x = Symbol('x', real=True) - assert set(PropertiesOnlyMatrix(2,2,[x,0,0,1]).values()) == set([x,1]) + assert set(PropertiesOnlyMatrix(2, 2, [x, 0, 0, 1] + ).values()) == set([x, 1]) # OperationsOnlyMatrix tests @@ -481,10 +483,12 @@ def test_adjoint(): def test_as_real_imag(): - m1 = OperationsOnlyMatrix(2,2,[1,2,3,4]) - m3 = OperationsOnlyMatrix(2,2,[1+S.ImaginaryUnit,2+2*S.ImaginaryUnit,3+3*S.ImaginaryUnit,4+4*S.ImaginaryUnit]) + m1 = OperationsOnlyMatrix(2, 2, [1, 2, 3, 4]) + m3 = OperationsOnlyMatrix(2, 2, + [1 + S.ImaginaryUnit, 2 + 2*S.ImaginaryUnit, + 3 + 3*S.ImaginaryUnit, 4 + 4*S.ImaginaryUnit]) - a,b = m3.as_real_imag() + a, b = m3.as_real_imag() assert a == m1 assert b == m1 @@ -508,7 +512,7 @@ def test_conjugate(): def test_doit(): - a = OperationsOnlyMatrix([[Add(x,x, evaluate=False)]]) + a = OperationsOnlyMatrix([[Add(x, x, evaluate=False)]]) assert a[0] != 2*x assert a.doit() == Matrix([[2*x]]) @@ -606,7 +610,7 @@ def test_xreplace(): def test_permute(): a = OperationsOnlyMatrix(3, 4, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]) - raises(IndexError, lambda: a.permute([[0,5]])) + raises(IndexError, lambda: a.permute([[0, 5]])) b = a.permute_rows([[0, 2], [0, 1]]) assert a.permute([[0, 2], [0, 1]]) == b == Matrix([ [5, 6, 7, 8], @@ -781,7 +785,7 @@ def test_div(): # DeterminantOnlyMatrix tests def test_det(): - a = DeterminantOnlyMatrix(2,3,[1,2,3,4,5,6]) + a = DeterminantOnlyMatrix(2, 3, [1, 2, 3, 4, 5, 6]) raises(NonSquareMatrixError, lambda: a.det()) z = zeros_Determinant(2) @@ -790,11 +794,12 @@ def test_det(): assert ey.det() == 1 x = Symbol('x') - a = DeterminantOnlyMatrix(0,0,[]) - b = DeterminantOnlyMatrix(1,1,[5]) - c = DeterminantOnlyMatrix(2,2,[1,2,3,4]) - d = DeterminantOnlyMatrix(3,3,[1,2,3,4,5,6,7,8,8]) - e = DeterminantOnlyMatrix(4,4,[x,1,2,3,4,5,6,7,2,9,10,11,12,13,14,14]) + a = DeterminantOnlyMatrix(0, 0, []) + b = DeterminantOnlyMatrix(1, 1, [5]) + c = DeterminantOnlyMatrix(2, 2, [1, 2, 3, 4]) + d = DeterminantOnlyMatrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 8]) + e = DeterminantOnlyMatrix(4, 4, + [x, 1, 2, 3, 4, 5, 6, 7, 2, 9, 10, 11, 12, 13, 14, 14]) # the method keyword for `det` doesn't kick in until 4x4 matrices, # so there is no need to test all methods on smaller ones @@ -811,7 +816,8 @@ def test_det(): def test_adjugate(): x = Symbol('x') - e = DeterminantOnlyMatrix(4,4,[x,1,2,3,4,5,6,7,2,9,10,11,12,13,14,14]) + e = DeterminantOnlyMatrix(4, 4, + [x, 1, 2, 3, 4, 5, 6, 7, 2, 9, 10, 11, 12, 13, 14, 14]) adj = Matrix([ [ 4, -8, 4, 0], @@ -822,13 +828,14 @@ def test_adjugate(): assert e.adjugate(method='bareiss') == adj assert e.adjugate(method='berkowitz') == adj - a = DeterminantOnlyMatrix(2,3,[1,2,3,4,5,6]) + a = DeterminantOnlyMatrix(2, 3, [1, 2, 3, 4, 5, 6]) raises(NonSquareMatrixError, lambda: a.adjugate()) def test_cofactor_and_minors(): x = Symbol('x') - e = DeterminantOnlyMatrix(4,4,[x,1,2,3,4,5,6,7,2,9,10,11,12,13,14,14]) + e = DeterminantOnlyMatrix(4, 4, + [x, 1, 2, 3, 4, 5, 6, 7, 2, 9, 10, 11, 12, 13, 14, 14]) m = Matrix([ [ x, 1, 3], @@ -844,31 +851,32 @@ def test_cofactor_and_minors(): [4, 5, 6], [2, 9, 10]]) - assert e.minor_submatrix(1,2) == m - assert e.minor_submatrix(-1,-1) == sub - assert e.minor(1,2) == -17*x - 142 - assert e.cofactor(1,2) == 17*x + 142 + assert e.minor_submatrix(1, 2) == m + assert e.minor_submatrix(-1, -1) == sub + assert e.minor(1, 2) == -17*x - 142 + assert e.cofactor(1, 2) == 17*x + 142 assert e.cofactor_matrix() == cm assert e.cofactor_matrix(method="bareiss") == cm assert e.cofactor_matrix(method="berkowitz") == cm - raises(ValueError, lambda: e.cofactor(4,5)) - raises(ValueError, lambda: e.minor(4,5)) - raises(ValueError, lambda: e.minor_submatrix(4,5)) + raises(ValueError, lambda: e.cofactor(4, 5)) + raises(ValueError, lambda: e.minor(4, 5)) + raises(ValueError, lambda: e.minor_submatrix(4, 5)) - a = DeterminantOnlyMatrix(2,3,[1,2,3,4,5,6]) - assert a.minor_submatrix(0,0) == Matrix([[5, 6]]) + a = DeterminantOnlyMatrix(2, 3, [1, 2, 3, 4, 5, 6]) + assert a.minor_submatrix(0, 0) == Matrix([[5, 6]]) - raises(ValueError, lambda: DeterminantOnlyMatrix(0,0,[]).minor_submatrix(0,0)) - raises(NonSquareMatrixError, lambda: a.cofactor(0,0)) - raises(NonSquareMatrixError, lambda: a.minor(0,0)) + raises(ValueError, lambda: + DeterminantOnlyMatrix(0, 0, []).minor_submatrix(0, 0)) + raises(NonSquareMatrixError, lambda: a.cofactor(0, 0)) + raises(NonSquareMatrixError, lambda: a.minor(0, 0)) raises(NonSquareMatrixError, lambda: a.cofactor_matrix()) def test_charpoly(): x, y = Symbol('x'), Symbol('y') - m = DeterminantOnlyMatrix(3,3,[1,2,3,4,5,6,7,8,9]) + m = DeterminantOnlyMatrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 9]) assert eye_Determinant(3).charpoly(x) == Poly((x - 1)**3, x) assert eye_Determinant(3).charpoly(y) == Poly((y - 1)**3, y) @@ -1007,7 +1015,7 @@ def verify_row_null_space(mat, rows, nulls): [ 1], [-2], [ 1]])] - rows = [a[i,:] for i in range(a.rows)] + rows = [a[i, :] for i in range(a.rows)] a_echelon = a.echelon_form() assert a_echelon.is_echelon verify_row_null_space(a, rows, nulls) @@ -1015,7 +1023,7 @@ def verify_row_null_space(mat, rows, nulls): a = ReductionsOnlyMatrix(3, 3, [1, 2, 3, 4, 5, 6, 7, 8, 8]) nulls = [] - rows = [a[i,:] for i in range(a.rows)] + rows = [a[i, :] for i in range(a.rows)] a_echelon = a.echelon_form() assert a_echelon.is_echelon verify_row_null_space(a, rows, nulls) @@ -1029,7 +1037,7 @@ def verify_row_null_space(mat, rows, nulls): [-S(3)/2], [ 0], [ 1]])] - rows = [a[i,:] for i in range(a.rows)] + rows = [a[i, :] for i in range(a.rows)] a_echelon = a.echelon_form() assert a_echelon.is_echelon verify_row_null_space(a, rows, nulls) @@ -1040,7 +1048,7 @@ def verify_row_null_space(mat, rows, nulls): [ 0], [ -3], [ 1]])] - rows = [a[i,:] for i in range(a.rows)] + rows = [a[i, :] for i in range(a.rows)] a_echelon = a.echelon_form() assert a_echelon.is_echelon verify_row_null_space(a, rows, nulls) @@ -1054,7 +1062,7 @@ def verify_row_null_space(mat, rows, nulls): [ 0], [-1], [ 1]])] - rows = [a[i,:] for i in range(a.rows)] + rows = [a[i, :] for i in range(a.rows)] a_echelon = a.echelon_form() assert a_echelon.is_echelon verify_row_null_space(a, rows, nulls) @@ -1064,7 +1072,7 @@ def verify_row_null_space(mat, rows, nulls): [-1], [1], [0]])] - rows = [a[i,:] for i in range(a.rows)] + rows = [a[i, :] for i in range(a.rows)] a_echelon = a.echelon_form() assert a_echelon.is_echelon verify_row_null_space(a, rows, nulls) @@ -1137,24 +1145,24 @@ def test_rref(): # SpecialOnlyMatrix tests def test_eye(): - assert list(SpecialOnlyMatrix.eye(2,2)) == [1, 0, 0, 1] + assert list(SpecialOnlyMatrix.eye(2, 2)) == [1, 0, 0, 1] assert list(SpecialOnlyMatrix.eye(2)) == [1, 0, 0, 1] assert type(SpecialOnlyMatrix.eye(2)) == SpecialOnlyMatrix assert type(SpecialOnlyMatrix.eye(2, cls=Matrix)) == Matrix def test_ones(): - assert list(SpecialOnlyMatrix.ones(2,2)) == [1, 1, 1, 1] + assert list(SpecialOnlyMatrix.ones(2, 2)) == [1, 1, 1, 1] assert list(SpecialOnlyMatrix.ones(2)) == [1, 1, 1, 1] - assert SpecialOnlyMatrix.ones(2,3) == Matrix([[1, 1, 1], [1, 1, 1]]) + assert SpecialOnlyMatrix.ones(2, 3) == Matrix([[1, 1, 1], [1, 1, 1]]) assert type(SpecialOnlyMatrix.ones(2)) == SpecialOnlyMatrix assert type(SpecialOnlyMatrix.ones(2, cls=Matrix)) == Matrix def test_zeros(): - assert list(SpecialOnlyMatrix.zeros(2,2)) == [0, 0, 0, 0] + assert list(SpecialOnlyMatrix.zeros(2, 2)) == [0, 0, 0, 0] assert list(SpecialOnlyMatrix.zeros(2)) == [0, 0, 0, 0] - assert SpecialOnlyMatrix.zeros(2,3) == Matrix([[0, 0, 0], [0, 0, 0]]) + assert SpecialOnlyMatrix.zeros(2, 3) == Matrix([[0, 0, 0], [0, 0, 0]]) assert type(SpecialOnlyMatrix.zeros(2)) == SpecialOnlyMatrix assert type(SpecialOnlyMatrix.zeros(2, cls=Matrix)) == Matrix @@ -1464,8 +1472,10 @@ def test_jordan_form(): P, J = A.jordan_form() assert simplify(P*J*P.inv()) == A - assert EigenOnlyMatrix(1,1,[1]).jordan_form() == (Matrix([1]), Matrix([1])) - assert EigenOnlyMatrix(1,1,[1]).jordan_form(calc_transform=False) == Matrix([1]) + assert EigenOnlyMatrix(1, 1, [1]).jordan_form() == ( + Matrix([1]), Matrix([1])) + assert EigenOnlyMatrix(1, 1, [1]).jordan_form( + calc_transform=False) == Matrix([1]) # make sure if we cannot factor the characteristic polynomial, we raise an error m = Matrix([[3, 0, 0, 0, -3], [0, -3, -3, 0, 3], [0, 3, 0, 3, 0], [0, 0, 3, 0, 3], [3, 0, 0, 3, 0]]) @@ -1538,7 +1548,7 @@ def test_jacobian2(): m = CalculusOnlyMatrix(2, 2, [1, 2, 3, 4]) m2 = CalculusOnlyMatrix(4, 1, [1, 2, 3, 4]) - raises(TypeError, lambda: m.jacobian(Matrix([1,2]))) + raises(TypeError, lambda: m.jacobian(Matrix([1, 2]))) raises(TypeError, lambda: m2.jacobian(m)) @@ -1550,7 +1560,7 @@ def test_limit(): def test_issue_13774(): M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) - v = [1,1,1] + v = [1, 1, 1] raises(TypeError, lambda: M*v) raises(TypeError, lambda: v*M) diff --git a/sympy/matrices/tests/test_sparsetools.py b/sympy/matrices/tests/test_sparsetools.py index 0782f2e51144..43634a3c53c5 100644 --- a/sympy/matrices/tests/test_sparsetools.py +++ b/sympy/matrices/tests/test_sparsetools.py @@ -1,5 +1,6 @@ -from sympy.matrices.sparsetools import _doktocsr, _csrtodok -from sympy import SparseMatrix +from sympy.matrices.sparsetools import _doktocsr, _csrtodok, banded +from sympy import eye, ones, zeros, Matrix, SparseMatrix +from sympy.utilities.pytest import raises def test_doktocsr(): @@ -36,3 +37,93 @@ def test_csrtodok(): assert _csrtodok(j) == SparseMatrix(5, 8, {(0, 2): 11, (2, 4): 15, (3, 1): 12, (4, 2): 15}) assert _csrtodok(k) == SparseMatrix(3, 3, {(0, 2): 1, (2, 1): 3}) + + +def test_banded(): + raises(TypeError, lambda: banded()) + raises(TypeError, lambda: banded(1)) + raises(TypeError, lambda: banded(1, 2)) + raises(TypeError, lambda: banded(1, 2, 3)) + raises(TypeError, lambda: banded(1, 2, 3, 4)) + raises(ValueError, lambda: banded({0: (1, 2)}, rows=1)) + raises(ValueError, lambda: banded({0: (1, 2)}, cols=1)) + raises(ValueError, lambda: banded(1, {0: (1, 2)})) + raises(ValueError, lambda: banded(2, 1, {0: (1, 2)})) + raises(ValueError, lambda: banded(1, 2, {0: (1, 2)})) + + assert isinstance(banded(2, 4, {}), SparseMatrix) + assert banded(2, 4, {}) == zeros(2, 4) + assert banded({0: 0, 1: 0}) == zeros(0) + assert banded({0: Matrix([1, 2])}) == Matrix([1, 2]) + assert banded({1: [1, 2, 3, 0], -1: [4, 5, 6]}) == \ + banded({1: (1, 2, 3), -1: (4, 5, 6)}) == \ + Matrix([ + [0, 1, 0, 0], + [4, 0, 2, 0], + [0, 5, 0, 3], + [0, 0, 6, 0]]) + assert banded(3, 4, {-1: 1, 0: 2, 1: 3}) == \ + Matrix([ + [2, 3, 0, 0], + [1, 2, 3, 0], + [0, 1, 2, 3]]) + s = lambda d: (1 + d)**2 + assert banded(5, {0: s, 2: s}) == \ + Matrix([ + [1, 0, 1, 0, 0], + [0, 4, 0, 4, 0], + [0, 0, 9, 0, 9], + [0, 0, 0, 16, 0], + [0, 0, 0, 0, 25]]) + assert banded(2, {0: 1}) == \ + Matrix([ + [1, 0], + [0, 1]]) + assert banded(2, 3, {0: 1}) == \ + Matrix([ + [1, 0, 0], + [0, 1, 0]]) + vert = Matrix([1, 2, 3]) + assert banded({0: vert}, cols=3) == \ + Matrix([ + [1, 0, 0], + [2, 1, 0], + [3, 2, 1], + [0, 3, 2], + [0, 0, 3]]) + assert banded(4, {0: ones(2)}) == \ + Matrix([ + [1, 1, 0, 0], + [1, 1, 0, 0], + [0, 0, 1, 1], + [0, 0, 1, 1]]) + raises(ValueError, lambda: banded({0: 2, 1: ones(2)}, rows=5)) + assert banded({0: 2, 2: (ones(2),)*3}) == \ + Matrix([ + [2, 0, 1, 1, 0, 0, 0, 0], + [0, 2, 1, 1, 0, 0, 0, 0], + [0, 0, 2, 0, 1, 1, 0, 0], + [0, 0, 0, 2, 1, 1, 0, 0], + [0, 0, 0, 0, 2, 0, 1, 1], + [0, 0, 0, 0, 0, 2, 1, 1]]) + raises(ValueError, lambda: banded({0: (2,)*5, 1: (ones(2),)*3})) + u2 = Matrix([[1, 1], [0, 1]]) + assert banded({0: (2,)*5, 1: (u2,)*3}) == \ + Matrix([ + [2, 1, 1, 0, 0, 0, 0], + [0, 2, 1, 0, 0, 0, 0], + [0, 0, 2, 1, 1, 0, 0], + [0, 0, 0, 2, 1, 0, 0], + [0, 0, 0, 0, 2, 1, 1], + [0, 0, 0, 0, 0, 0, 1]]) + assert banded({0:(0, ones(2)), 2: 2}) == \ + Matrix([ + [0, 0, 2], + [0, 1, 1], + [0, 1, 1]]) + raises(ValueError, lambda: banded({0: (0, ones(2)), 1: 2})) + assert banded({0: 1}, cols=3) == banded({0: 1}, rows=3) == eye(3) + assert banded({1: 1}, rows=3) == Matrix([ + [0, 1, 0], + [0, 0, 1], + [0, 0, 0]])

[ { "components": [ { "doc": "Returns a SparseMatrix from the given dictionary describing\nthe diagonals of the matrix. The keys are positive for upper\ndiagonals and negative for those below the main diagonal. The\nvalues may be:\n * expressions or single-argument functions,\n * lists or tupl...

[ "test_doktocsr", "test_csrtodok" ]

[ "test__MinimalMatrix", "test_vec", "test_tolist", "test_row_col_del", "test_get_diag_blocks1", "test_get_diag_blocks2", "test_shape", "test_reshape", "test_row_col", "test_row_join", "test_col_join", "test_row_insert", "test_col_insert", "test_extract", "test_hstack", "test_vstack", ...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> banded matrix construction  #### References to other Issues or PRs  closes #16180 as alternate fixes #16178 #### Brief description of what is fixed or changed A syntax is proposed whereby banded matrices can be created. The input to `banded` is a dictionary containing keys for the diagonal to fill, and values containing information about what to put on the diagonal: ``` {0: 1} - 1s on the main diagonal {0: x, 1:1} - an upper Jordan-block matrix {1: (1, 2, 3), -1: (4, 5, 6)} - 1, 2, 3 on the 1st diag above main and 4, 5, 6 on the diagonal below the main ``` The values above can also be matrices/lists or single argument functions which calculate the value on the diagonal based on the displacement along the diagonal. #### Other comments This is not a class of matrix, it is just a helper function for creating the matrix. The rationale for this is that one should not need to instantiate a full matrix if only needing to define values down a few diagonals. It automatically comes back as a SparseMatrix which can be fed to any other matrix constructor if another type is needed (e.g. dense). #### Release Notes   - matrices - `banded` added to sparsetools.py as a helper to create a banded matrices  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/matrices/sparsetools.py] (definition of banded:) def banded(*args, **kwargs): """Returns a SparseMatrix from the given dictionary describing the diagonals of the matrix. The keys are positive for upper diagonals and negative for those below the main diagonal. The values may be: * expressions or single-argument functions, * lists or tuples of values, * matrices Unless dimensions are given, the size of the returned matrix will be large enough to contain the largest non-zero value provided. kwargs ====== rows : rows of the resulting matrix; computed if not given. cols : columns of the resulting matrix; computed if not given. Examples ======== >>> from sympy import banded, ones, Matrix >>> from sympy.abc import x If explicit values are given in tuples, the matrix will autosize to contain all values, otherwise a single value is filled onto the entire diagonal: >>> banded({1: (1, 2, 3), -1: (4, 5, 6), 0: x}) Matrix([ [x, 1, 0, 0], [4, x, 2, 0], [0, 5, x, 3], [0, 0, 6, x]]) A function accepting a single argument can be used to fill the diagonal as a function of diagonal index (which starts at 0). The size (or shape) of the matrix must be given to obtain more than a 1x1 matrix: >>> s = lambda d: (1 + d)**2 >>> banded(5, {0: s, 2: s, -2: 2}) Matrix([ [1, 0, 1, 0, 0], [0, 4, 0, 4, 0], [2, 0, 9, 0, 9], [0, 2, 0, 16, 0], [0, 0, 2, 0, 25]]) The diagonal of matrices placed on a diagonal will coincide with the indicated diagonal: >>> vert = Matrix([1, 2, 3]) >>> banded({0: vert}, cols=3) Matrix([ [1, 0, 0], [2, 1, 0], [3, 2, 1], [0, 3, 2], [0, 0, 3]]) >>> banded(4, {0: ones(2)}) Matrix([ [1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 1], [0, 0, 1, 1]]) Errors are raised if the designated size will not hold all values an integral number of times. Here, the rows are designated as odd (but an even number is required to hold the off-diagonal 2x2 ones): >>> banded({0: 2, 1: ones(2)}, rows=5) Traceback (most recent call last): ... ValueError: sequence does not fit an integral number of times in the matrix And here, an even number of rows is given...but the square matrix has an even number of columns, too. As we saw in the previous example, an odd number is required: >>> banded(4, {0: 2, 1: ones(2)}) # trying to make 4x4 and cols must be odd Traceback (most recent call last): ... ValueError: sequence does not fit an integral number of times in the matrix A way around having to count rows is to enclosing matrix elements in a tuple and indicate the desired number of them to the right: >>> banded({0: 2, 2: (ones(2),)*3}) Matrix([ [2, 0, 1, 1, 0, 0, 0, 0], [0, 2, 1, 1, 0, 0, 0, 0], [0, 0, 2, 0, 1, 1, 0, 0], [0, 0, 0, 2, 1, 1, 0, 0], [0, 0, 0, 0, 2, 0, 1, 1], [0, 0, 0, 0, 0, 2, 1, 1]]) An error will be raised if more than one value is written to a given entry. Here, the ones overlap with the main diagonal if they are placed on the first diagonal: >>> banded({0: (2,)*5, 1: (ones(2),)*3}) Traceback (most recent call last): ... ValueError: collision at (1, 1) By placing a 0 at the bottom left of the 2x2 matrix of ones, the collision is avoided: >>> u2 = Matrix([ ... [1, 1], ... [0, 1]]) >>> banded({0: [2]*5, 1: [u2]*3}) Matrix([ [2, 1, 1, 0, 0, 0, 0], [0, 2, 1, 0, 0, 0, 0], [0, 0, 2, 1, 1, 0, 0], [0, 0, 0, 2, 1, 0, 0], [0, 0, 0, 0, 2, 1, 1], [0, 0, 0, 0, 0, 0, 1]])""" (definition of banded.rc:) def rc(d): (definition of banded.update:) def update(i, j, v): [end of new definitions in sympy/matrices/sparsetools.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Modified function for easy creation of banded matrices  #### References to other Issues or PRs Fixes #16178  #### Brief description of what is fixed or changed In the above mentioned way of passing a dictionary giving diagonal number and the value, I was successful in implementing it for dictionary values as just numbers or as lists in case if the values for the diagonal are not all the same. ``` >>> Matrix.diag({0: 1, 1: 2},rows=3,cols=4) Matrix([ [1, 2, 0, 0], [0, 1, 2, 0], [0, 0, 1, 2]]) >>> Matrix.diag({1: [1,2,3],0:1,-1:[-2,3]}, rows=3, cols=4) Matrix([ [ 1, 1, 0, 0], [-2, 1, 2, 0], [ 0, 3, 1, 3]]) >>> Matrix.diag({1: [1,2,3],0:1,-1:[-2,3,4]}, rows=3, cols=4) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "sympy/matrices/common.py", line 773, in diag raise ValueError("The size of list provided should match the diagonal size") ValueError: The size of list provided should match the diagonal size ``` when the value of dictionary is a function ``` >>> Matrix.diag({1: [1,2,3],0:(lambda i, j: i + 1) ,-1:[-2,3]}, rows=3, cols=4) Matrix([ [ 1, 1, 0, 0], [-2, 2, 2, 0], [ 0, 3, 3, 3]]) >>> Matrix.diag({-1: [-1, -2], 0: lambda i, j: i + j, 1: lambda d: 2*d + 1,2:4}, rows=3, cols=4) Matrix([ [ 0, 1, 4, 0], [-1, 2, 3, 4], [ 0, -2, 4, 5]]) ``` #### Other comments #### Release Notes   * matrices * Added cases for checking the type of parameters passed and create matrix accordingly in the Matrix.diag function of common.py * Added the functionality where bands off the diagonal can be made by using a dictionary whose keys tell the diagonal  ---------- :white_check_mark: Hi, I am the [SymPy bot](https://github.com/sympy/sympy-bot) (v142). I'm here to help you write a release notes entry. Please read the [guide on how to write release notes](https://github.com/sympy/sympy/wiki/Writing-Release-Notes). Your release notes are in good order. Here is what the release notes will look like: * matrices * Added cases for checking the type of parameters passed and create matrix accordingly in the Matrix.diag function of common.py ([#16180](https://github.com/sympy/sympy/pull/16180) by [@GYeyosi](https://github.com/GYeyosi) and [@smichr](https://github.com/smichr)) * Added the functionality where bands off the diagonal can be made by using a dictionary whose keys tell the diagonal ([#16180](https://github.com/sympy/sympy/pull/16180) by [@GYeyosi](https://github.com/GYeyosi) and [@smichr](https://github.com/smichr)) This will be added to https://github.com/sympy/sympy/wiki/Release-Notes-for-1.4. Note: This comment will be updated with the latest check if you edit the pull request. You need to reload the page to see it. <details><summary>Click here to see the pull request description that was parsed.</summary>  #### References to other Issues or PRs Fixes #16178  #### Brief description of what is fixed or changed In the above mentioned way of passing a dictionary giving diagonal number and the value, I was successful in implementing it for dictionary values as just numbers or as lists in case if the values for the diagonal are not all the same. ``` >>> Matrix.diag({0: 1, 1: 2},rows=3,cols=4) Matrix([ [1, 2, 0, 0], [0, 1, 2, 0], [0, 0, 1, 2]]) >>> Matrix.diag({1: [1,2,3],0:1,-1:[-2,3]}, rows=3, cols=4) Matrix([ [ 1, 1, 0, 0], [-2, 1, 2, 0], [ 0, 3, 1, 3]]) >>> Matrix.diag({1: [1,2,3],0:1,-1:[-2,3,4]}, rows=3, cols=4) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "sympy/matrices/common.py", line 773, in diag raise ValueError("The size of list provided should match the diagonal size") ValueError: The size of list provided should match the diagonal size ``` when the value of dictionary is a function ``` >>> Matrix.diag({1: [1,2,3],0:(lambda i, j: i + 1) ,-1:[-2,3]}, rows=3, cols=4) Matrix([ [ 1, 1, 0, 0], [-2, 2, 2, 0], [ 0, 3, 3, 3]]) >>> Matrix.diag({-1: [-1, -2], 0: lambda i, j: i + j, 1: lambda d: 2*d + 1,2:4}, rows=3, cols=4) Matrix([ [ 0, 1, 4, 0], [-1, 2, 3, 4], [ 0, -2, 4, 5]]) ``` #### Other comments #### Release Notes   * matrices * Added cases for checking the type of parameters passed and create matrix accordingly in the Matrix.diag function of common.py * Added the functionality where bands off the diagonal can be made by using a dictionary whose keys tell the diagonal  </details><p> Now we have to make sure that it plays nicely with other diagonal elements: ``` >>> M=Matrix;M.diag(11,22,{1:1,3:3,-3:-2,'size':(5,5)},33) Matrix([ [11, 0, 0, 0, 0, 0, 0, 0], [ 0, 22, 0, 0, 0, 0, 0, 0], [ 0, 0, 0, 1, 0, 3, 0, 0], [ 0, 0, 0, 0, 1, 0, 3, 0], [ 0, 0, 0, 0, 0, 1, 0, 0], [ 0, 0, -2, 0, 0, 0, 0, 0], [ 0, 0, 0, -2, 0, 0, 0, 0], [ 0, 0, 0, 0, 0, 0, 0, 33]]) ``` Something like this, maybe? ```diff diff --git a/sympy/matrices/common.py b/sympy/matrices/common.py index 94589d6..2428b18 100644 --- a/sympy/matrices/common.py +++ b/sympy/matrices/common.py @@ -7,6 +7,7 @@ from __future__ import division, print_function from collections import defaultdict +from inspect import isfunction from types import FunctionType from sympy.assumptions.refine import refine @@ -15,13 +16,14 @@ Iterable, as_int, is_sequence, range, reduce) from sympy.core.decorators import call_highest_priority from sympy.core.expr import Expr -from sympy.core.function import count_ops +from sympy.core.function import count_ops, _getnargs from sympy.core.singleton import S from sympy.core.symbol import Symbol from sympy.core.sympify import sympify from sympy.functions import Abs from sympy.simplify import simplify as _simplify from sympy.utilities.iterables import flatten +from sympy.utilities.misc import filldedent class MatrixError(Exception): @@ -733,11 +735,21 @@ def size(m): if hasattr(m, 'rows'): return m.rows, m.cols if isinstance(m, dict): - return kwargs.get('rows'), kwargs.get('cols') + rv = m.pop('size', (kwargs.get('rows'), kwargs.get('cols'))) + if None in rv: + raise ValueError(filldedent(''' + If size is not given in dict the `rows` and `cols` + must be given as arg to diag.''')) + return rv return 1, 1 - - diag_rows = sum(size(m)[0] for m in args) - diag_cols = sum(size(m)[1] for m in args) + dict_sizes = [] + diag_rows = diag_cols = 0 + for m in args: + s = r, c = size(m) + if isinstance(m, dict): + dict_sizes.append(s) + diag_rows += r + diag_cols += c rows = kwargs.get('rows', diag_rows) cols = kwargs.get('cols', diag_cols) if rows < diag_rows or cols < diag_cols: @@ -748,55 +760,62 @@ def size(m): # fill a default dict with the diagonal entries diag_entries = defaultdict(lambda: S.Zero) row_pos, col_pos = 0, 0 + ndict = 0 for m in args: - if hasattr(m, 'rows'): - # in this case, we're a matrix + if hasattr(m, 'rows'): # a matrix for i in range(m.rows): for j in range(m.cols): diag_entries[(i + row_pos, j + col_pos)] = m[i, j] row_pos += m.rows col_pos += m.cols - elif isinstance(m, dict): - # in this case we're a dict + elif not isinstance(m, dict): # a single value + diag_entries[(row_pos, col_pos)] = m + row_pos += 1 + col_pos += 1 + else: # a dict + ix = lambda r, c: (row_pos + r, col_pos + c) + r, c = dict_sizes[ndict] + rmax = r - 1 + cmax = c - 1 for key, value in m.items(): key = as_int(key) - assert(key < diag_rows and key < diag_cols) r_p = 0 if key >= 0 else -key c_p = key if key > 0 else 0 - func_arg = 0 - while (r_p < diag_rows and c_p < diag_cols): - from inspect import isfunction - from sympy.core.function import _getnargs - + if r_p > rmax or c_p > cmax: + raise ValueError(filldedent(''' + dict-specified diagonal index out of range''')) + d = 0 + dlen = d + 1 + while (r_p < diag_rows and c_p < diag_cols and d < dlen): + dlen = min(rmax - r_p + 1, cmax - c_p + 1) if(isinstance(value, list)): - if(len(value) != min(diag_rows - r_p, diag_cols - c_p)): - raise ValueError("The size of list provided should match the diagonal size") + if(len(value) != dlen): + raise ValueError(filldedent(''' + The size of list provided should + match the diagonal size.''')) for i in range(len(value)): - diag_entries[(r_p, c_p)] = value[i] + diag_entries[ix(r_p, c_p)] = value[i] r_p += 1 c_p += 1 elif(isfunction(value)): num_args = _getnargs(value) - # print(num_args) - if(num_args == 2): - diag_entries[(r_p, c_p)] = value(r_p, c_p) - elif(num_args == 1): - diag_entries[(r_p, c_p)] = value(func_arg) - func_arg += 1 + if num_args == 2: + diag_entries[ix(r_p, c_p)] = value(r_p, c_p) + elif num_args == 1: + diag_entries[ix(r_p, c_p)] = value(d) else: - raise ValueError("While passing function as a value in dictionary number of arguments must be either 1 or 2") - r_p += 1 - c_p += 1 + raise ValueError(filldedent(''' + The functions in dict-described + diagonals must have 1 or 2 args.''')) else: - diag_entries[(r_p, c_p)] = value - r_p += 1 - c_p += 1 - - else: - # in this case, we're a single value - diag_entries[(row_pos, col_pos)] = m - row_pos += 1 - col_pos += 1 + diag_entries[ix(r_p, c_p)] = value + r_p += 1 + c_p += 1 + d += 1 + r, c = dict_sizes[ndict] + row_pos += r + col_pos += c + ndict += 1 return klass._eval_diag(rows, cols, diag_entries) @classmethod ``` I didn't consider the case, where dictionary is constricted with some **size**, other values given. This looks great, I'll add it. But, ``` > + while (r_p < diag_rows and c_p < diag_cols and d < dlen): ``` In this line it must be d <= dlen. The following fails if it was d < dlen ``` >>> Matrix.diag({0: 1, 1: 2},rows=3,cols=4) Matrix([ [1, 2, 0, 0], [0, 1, 2, 0], [0, 0, 0, 0]]) >>> ``` Actual output is ``` >>> Matrix.diag({0: 1, 1: 2},rows=3,cols=4) Matrix([ [1, 2, 0, 0], [0, 1, 2, 0], [0, 0, 1, 2]]) ``` I've made changes accordingly. Perhaps the dict could be a little flexible in size: ```diff diff --git a/sympy/matrices/common.py b/sympy/matrices/common.py index 2428b18..b2fb3ff 100644 --- a/sympy/matrices/common.py +++ b/sympy/matrices/common.py @@ -739,7 +739,7 @@ def size(m): if None in rv: raise ValueError(filldedent(''' If size is not given in dict the `rows` and `cols` - must be given as arg to diag.''')) + must be given as args to diag.''')) return rv return 1, 1 dict_sizes = [] @@ -753,9 +753,17 @@ def size(m): rows = kwargs.get('rows', diag_rows) cols = kwargs.get('cols', diag_cols) if rows < diag_rows or cols < diag_cols: - raise ValueError("A {} x {} diagnal matrix cannot accommodate a" - "diagonal of size at least {} x {}.".format(rows, cols, - diag_rows, diag_cols)) + if len(dict_sizes) == 1 and len(args) > 1: + r, c = dict_sizes[0] + dict_sizes = [ + (r - (diag_rows - rows), c - (diag_cols - cols))] + diag_rows = rows + diag_cols = cols + else: + raise ValueError(filldedent(''' + The diagonal elements need a matrix that is {} x {} + but only {} x {} has been specified.'''.format( + diag_rows, diag_cols, rows, cols))) # fill a default dict with the diagonal entries diag_entries = defaultdict(lambda: S.Zero) ``` Here are some possible tests: ```python >>> Matrix.diag(1, {1:2}, rows=3, cols=4) Matrix([ [1, 0, 0, 0], [0, 0, 2, 0], [0, 0, 0, 2]]) >>> Matrix.diag(1, {1: 2, 'size': (2, 2)}, rows=3, cols=4) Matrix([ [1, 0, 0, 0], [0, 0, 2, 0], [0, 0, 0, 0]]) >>> Matrix.diag(1, {1: 2, 'size': (2, 2)}, 3, rows=4, cols=4) Matrix([ [1, 0, 0, 0], [0, 0, 2, 0], [0, 0, 0, 0], [0, 0, 0, 3]]) >>> Matrix.diag(1, {1:2}, 3, rows=5, cols=5) Matrix([ [1, 0, 0, 0, 0], [0, 0, 2, 0, 0], [0, 0, 0, 2, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 3]]) >>> Matrix.diag(1, {-1: 2}, 3, rows=5, cols=5) Matrix([ [1, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 2, 0, 0, 0], [0, 0, 2, 0, 0], [0, 0, 0, 0, 3]]) ``` What should be the behaviour when user provides with an input of this type? ``` >>> Matrix.diag({0:1}, {1:2}, rows=3, cols=4) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "sympy/matrices/common.py", line 767, in diag diag_rows, diag_cols, rows, cols))) ValueError: The diagonal elements need a matrix that is 6 x 8 but only 3 x 4 has been specified. ``` Should we merge dictionaries? and make it ``` >>> Matrix.diag({0: 1, 1: 2},rows=3,cols=4) Matrix([ [1, 2, 0, 0], [0, 1, 2, 0], [0, 0, 1, 2]]) >>> ``` > Should we merge dictionaries? and make it Interesting that the un-specified size goes to the end of the diagonal whereas ```python >>> Matrix.diag({0: 1, 1: 2,'size':(3,3)},rows=3,cols=4) Matrix([ [1, 2, 0, 0], [0, 1, 2, 0], [0, 0, 1, 0]]) ``` This concatenation of contiguous dicts makes a nice method of being able to say what the diagonal should be, e.g. ``` >>> ones = {1:1, -1:1} >>> Matrix.diag(ones, {0:2*x}, rows=4, cols=4) Matrix([ [2*x, 1, 0, 0], [ 1, 2*x, 1, 0], [ 0, 1, 2*x, 1], [ 0, 0, 1, 0]]) ``` # [Codecov](https://codecov.io/gh/sympy/sympy/pull/16180?src=pr&el=h1) Report > Merging [#16180](https://codecov.io/gh/sympy/sympy/pull/16180?src=pr&el=desc) into [master](https://codecov.io/gh/sympy/sympy/commit/faad12d1307099aff62b559a84df40a999b8219c?src=pr&el=desc) will **increase** coverage by `0.01%`. > The diff coverage is `95.31%`. [![Impacted file tree graph](https://codecov.io/gh/sympy/sympy/pull/16180/graphs/tree.svg?width=650&token=RzuBMaa2lr&height=150&src=pr)](https://codecov.io/gh/sympy/sympy/pull/16180?src=pr&el=tree) ```diff @@ Coverage Diff @@ ## master #16180 +/- ## ========================================== + Coverage 73.14% 73.16% +0.01% ========================================== Files 618 618 Lines 157778 157949 +171 Branches 37116 37159 +43 ========================================== + Hits 115408 115564 +156 - Misses 36831 36833 +2 - Partials 5539 5552 +13 ``` | [Impacted Files](https://codecov.io/gh/sympy/sympy/pull/16180?src=pr&el=tree) | Coverage Δ | | |---|---|---| | [sympy/utilities/misc.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvdXRpbGl0aWVzL21pc2MucHk=) | `51.61% <0%> (-0.57%)` | :arrow_down: | | [sympy/core/function.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvY29yZS9mdW5jdGlvbi5weQ==) | `91.06% <42.85%> (-0.16%)` | :arrow_down: | | [sympy/matrices/common.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvbWF0cmljZXMvY29tbW9uLnB5) | `92.67% <98.36%> (+1.5%)` | :arrow_up: | | [sympy/combinatorics/perm\_groups.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvY29tYmluYXRvcmljcy9wZXJtX2dyb3Vwcy5weQ==) | `76.58% <0%> (-0.97%)` | :arrow_down: | | [sympy/combinatorics/homomorphisms.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvY29tYmluYXRvcmljcy9ob21vbW9ycGhpc21zLnB5) | `76.71% <0%> (-0.69%)` | :arrow_down: | | [sympy/stats/rv.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvc3RhdHMvcnYucHk=) | `84.24% <0%> (-0.41%)` | :arrow_down: | | [sympy/sets/handlers/intersection.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvc2V0cy9oYW5kbGVycy9pbnRlcnNlY3Rpb24ucHk=) | `91.4% <0%> (-0.4%)` | :arrow_down: | | [sympy/matrices/expressions/matexpr.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvbWF0cmljZXMvZXhwcmVzc2lvbnMvbWF0ZXhwci5weQ==) | `90.14% <0%> (-0.37%)` | :arrow_down: | | [sympy/polys/densebasic.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvcG9seXMvZGVuc2ViYXNpYy5weQ==) | `95.96% <0%> (-0.36%)` | :arrow_down: | | [sympy/polys/modulargcd.py](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree#diff-c3ltcHkvcG9seXMvbW9kdWxhcmdjZC5weQ==) | `97.36% <0%> (-0.26%)` | :arrow_down: | | ... and [7 more](https://codecov.io/gh/sympy/sympy/pull/16180/diff?src=pr&el=tree-more) | | ------ [Continue to review full report at Codecov](https://codecov.io/gh/sympy/sympy/pull/16180?src=pr&el=continue). > **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta) > `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data` > Powered by [Codecov](https://codecov.io/gh/sympy/sympy/pull/16180?src=pr&el=footer). Last update [faad12d...0fe2aa2](https://codecov.io/gh/sympy/sympy/pull/16180?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments). > Interesting that the un-specified size goes to the end of the diagonal whereas > > ```python > >>> Matrix.diag({0: 1, 1: 2,'size':(3,3)},rows=3,cols=4) > Matrix([ > [1, 2, 0, 0], > [0, 1, 2, 0], > [0, 0, 1, 0]]) > ``` What about this then, from the above discussions. ``` >>> Matrix.diag(1, {-1: 2}, 3, rows=5, cols=5) Matrix([ [1, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 2, 0, 0, 0], [0, 0, 2, 0, 0], [0, 0, 0, 0, 3]]) ``` In the above case, the dictionary is considered for inner 3x3 matrix, cause the other two arguments are just values. How should we deal with something like below, which has different possibilities `Matrix.diag(1, {-1: 2}, 3, {0: 1}, rows=6, cols=6)` where as if sizes are provided it is understandable. ``` >>> Matrix.diag(1, {-1: 2, 'size':(3,3)}, 3,{0: 1, 'size':(3,3)}, rows=9, cols=9) Matrix([ [1, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 3, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]]) >>> ``` So, what should I do with the possibility of having multiple dictionaries without their corresponding sizes ? Can you please help me out. After collapsing contiguous dictionaries, if there is more than one dictionary without 'size' key then raise an error. Something like this, perhaps? ```python newargs = [] nosize = 0 for a in args: if newargs and all(isinstance(i, dict) and 'size' not in i for i in (a, newargs[-1])): newargs[-1].updated(a) else: newargs.append(a) if isinstance(a, dict) and 'size' not in a: nosize += 1 if nosize > 1: raise ValueError(filldedent(''' non-contiguous dictionaries must have a size specified, e.g. {'size': (rows, cols), ...}''')) ``` I was just checking on [special block diagonal shapes](https://en.wikipedia.org/wiki/Block_matrix#Block_diagonal_matrices) and see that the "direct sum" is computed with this routine: ```python >>> A=Matrix(((1,2,3),(4,5,6))) >>> B=Matrix(((3,3),(4,4))) >>> Matrix.diag(A, B) # direct sum Matrix([ [1, 2, 3, 0, 0], [4, 5, 6, 0, 0], [0, 0, 0, 3, 3], [0, 0, 0, 4, 4]]) >>> ``` If there is only one dictionary and neither size, rows nor cols, the minimal size can be used: ```python def minsize(d): r = max(0, -min(d)) + 1 c = -min(0, -max(d)) + 1 for k in d: size = len(d[k]) if type(d[k]) is list else 0 r = max(r, abs(k) + size) c = max(c, abs(k) + size) return r, c >>> minsize({2:[4,5,6],-2:[1,2,3]}) (5, 5) >>> Matrix.diag({1:2,-2:1}) Matrix([ [0, 2], [0, 0], [1, 0]]) ``` > If there is only one dictionary and neither size, rows nor cols, the minimal size can be used: Yup, I'm actually implementing this now. I'll add it and push the changes. > Yup, I'm actually implementing this now. I'll add it and push the changes. Done with it, pushed the changes. @smichr can you please review it. I noticed that 1s were trailing out of range in what should be ``` >>> Matrix.diag({1:2,-2:1},4) Matrix([ [0, 2, 0], [0, 0, 0], [1, 0, 0], [0, 0, 4]]) ``` I modified that and tweaked what you have, too. > I was just checking on [special block diagonal shapes](https://en.wikipedia.org/wiki/Block_matrix#Block_diagonal_matrices) and see that the "direct sum" is computed with this routine: The DirectSum can be done as below. ``` class DirectSum(MatrixExpr): def __new__(cls, *args): if not args: return GenericZeroMatrix() # This must be removed aggressively in the constructor to avoid # TypeErrors from GenericZeroMatrix().shape args = filter(lambda i: GenericZeroMatrix() != i, args) args = list(map(sympify, args)) validate(*args) obj = Basic.__new__(cls, *args) return obj def doit(self): return Matrix.diag(self.args) def validate(*args): if not all(arg.is_Matrix for arg in args): raise TypeError("Mix of Matrix and Scalar symbols") ``` Should I add it to expressions ? > Should I add it to expressions ? I defer to others more familiar with Matrices. Rather than modify this directly here, I made a [PR to this branch](https://github.com/GYeyosi/sympy/pull/1) which I think you will be able to merge (or comment on before doing so). The function had grown too large. Is it possible to split some parts? The release notes entry should mention which function is actually affected by the change (Matrix.diag). > The release notes entry should mention which function is actually affected by the change (Matrix.diag) I've added it to the Release Notes. The only other thing I was thinking about was a more flexible way to position the filling. Instead of using kerning matrices (which only allow nonnegative motion) we could use keywords 'goto' and 'move' --or something like that--to indicate absolute position or relative motion, e.g. `diag(dict(move=(-2,0)), 1, 2, 3,dict(goto=(0,2)),4,5,6)` > The only other thing I was thinking about was a more flexible way to position the filling. Instead of using kerning matrices (which only allow nonnegative motion) we could use keywords 'goto' and 'move' --or something like that--to indicate absolute position or relative motion, e.g. `diag(dict(move=(-2,0)), 1, 2, 3,dict(goto=(0,2)),4,5,6)` I'm not sure if I understood what you meant exactly, is it like not using the integral keys in the dictionary but use these keywords to specify the position to start the filling? Can you please give an example explaining this. This `diag(dict(move=(-2,0)), 1, 2, 3,dict(goto=(0,2)),4,5,6)` would recreate the docstring example in which the kerning is used. Consider this, `diag({1:2, -2:1, 'move':(-2, 0)}, 1, 2, 3,dict(goto=(0, 2)), 4,5,6)` In the first dictionary, should I move the values down (2 rows) only of that dictionary, or the values 1, 2, 3 also must be moved? and in similar case with goto also. the motion directives would be singletons; they would not appear inside another dictionary. You can see my wip on my diag branch. I haven't yet settled how to compute size so the example I have been giving fails. I have seen the branch you mentioned, in your code the arg_size function can be written this way. ``` def arg_size(args): prev = None o_r, o_c, g_r, g_c, m_r, m_c = 0, 0, 0, 0, 0, 0 max_row, max_col = 0, 0 for a_ in args: a_size = size(a_) if type(a_) is dict and 'goto' in a_: prev = 'goto' prev_size = a_size g_r , g_c = prev_size[0], prev_size[1] continue elif type(a_) is dict and 'move' in a_: prev = 'move' prev_size = a_size continue else: o_r += a_size[0] o_c += a_size[1] if prev is None: if max_row < o_r: max_row = o_r if max_col < o_r: max_col = o_r continue if 'goto' in prev: g_r += a_size[0] g_c += a_size[1] if max_row < g_r: max_row = g_r if max_col < g_c: max_col = g_c elif 'move' in prev: m_r = o_r - prev_size[0] m_c = o_c - prev_size[1] # print(m_r, m_c) if max_row < m_r: max_row = m_r if max_col < m_c: max_col = m_c return max_row, max_col ``` I was working on code from your branch, successfully implemented it for arguments as values, i'm now extending it for matrices, dicts. Also, there are many unnecessary lines in it, needed to be modified. @smichr Can you please review the changes I've just made. Although the code is lengthy now, I hope all possible cases are covered. Can you please check if any test case fails. Does this do the same? ```python def arg_size(args): prev = None max_row, max_col, o_r, o_c = [0]*4 for a_ in args: a_size = size(a_) if type(a_) is dict and 'goto' in a_ or 'move' in a_: if 'goto' in a_: prev = 'goto' else: prev = 'move' prev_size = a_size else: R, C = a_size o_r += R o_c += C if prev is None: max_row = o_r max_col = o_c else: r, c = prev_size if prev == 'goto': max_row = max(max_row, R + r) max_col = max(max_col, C + c) else: # 'move' max_row = max(max_row, o_r - r) max_col = max(max_col, o_c - c) return max_row, max_col ``` > Does this do the same? I changed the line `if type(a_) is dict and 'goto' in a_ or 'move' in a_:` to `if type(a_) is dict and ('goto' in a_ or 'move' in a_):` cause the first one raises error if a_ is an integer. It gave the following result for `diag(dict(move=(-2,0)), 1, 2, 3,dict(goto=(0,2)),4,5,6)` of size `(5,3)` whereas it should be `(5,5)` ``` >>> diag(dict(move=(-2,0)), 1, 2, 3,dict(goto=(0,2)),4,5,6) Matrix([ [0, 0, 4], [0, 0, 0], [1, 0, 0], [0, 2, 0], [0, 0, 3]]) ``` I've tried simplifying the code Can you have a look at it and suggest further modifications that can be done. ```python def arg_size(args): prev = None max_row, max_col, o_r, o_c = [0]*4 for a_ in args: a_size = size(a_) if type(a_) is dict and ('goto' in a_ or 'move' in a_): p_r, p_c = a_size if 'goto' in a_: prev = 'goto' else: prev = 'move' else: o_r += a_size[0] o_c += a_size[1] if prev is None: max_row, max_col = o_r, o_c elif 'goto' in prev: max_row = max(max_row, p_r + g_r) max_col = max(max_col, p_c + g_c) elif 'move' in prev: max_row = max(max_row, o_r - p_r) max_col = max(max_col, o_c - pc) return max_row, max_col ``` > ```python >prev_size = a_size = size(a_) >if type(a_) is dict and 'goto' in a_: > prev = 'goto' > g_r , g_c = a_size > elif type(a_) is dict and 'move' in a_: > prev = 'move' > ``` prev_size should be changed to `size(a_)` only if a_ is `move`or `goto`, so I've made it ``` a_size = size(a_) if type(a_) is dict and 'goto' in a_: prev = 'goto' prev_size = size(a_) g_r , g_c = a_size elif type(a_) is dict and 'move' in a_: prev = 'move' prev_size = size(a_) ``` > prev_size should be changed only just saw that -- see update code that I last posted I've pushed the changes. Looks good. I got the issue #16233 fixed and added ValueErrors instead of Assertions. coverage of diag was 100% in terms of line coverage the last time I checked (but for some reason the report-writing is not working for the coverage test and I can't check it). update: it's still 100% :arrow_double_up: The new PR will fix the import error. Let's see if anyone else has some ideas about this approach. I see there is still a problem. ```python >>> diag({-2:1}, row=4,cols=4) Matrix([ [0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0]]) should be Matrix([ [0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0], [0, 1, 0, 0]]) ``` > I see there is still a problem. > ```python > >>> diag({-2:1}, row=4,cols=4) > Matrix([ > [0, 0, 0, 0], > [0, 0, 0, 0], > [1, 0, 0, 0]]) > > ``` The keyword to define number of rows is `rows` not `row` This API seems overly complex. It has taken me some time to understand it right now. As an example: ``` A kerning dictionary can be used to reposition the filling: {'move': (row change, col change)}, {'goto': (row, col)}, or {} (to go to the diagonal): >>> diag(7, {'move': (-1, -1)}, 1, 2, 3, {'goto': (0, 2)}, 4, 5, 6, {}, 8) Matrix([ [7, 0, 4, 0, 0, 0], [0, 0, 0, 5, 0, 0], [1, 0, 0, 0, 6, 0], [0, 2, 0, 0, 0, 0], [0, 0, 3, 0, 0, 0], [0, 0, 0, 0, 0, 8]]) ``` I can't really imagine wanting to do something like this and I wouldn't want to try and understand code that was written this way. Wouldn't this example be better written as this: ``` diag({0: [7]+4*[0], -2:[1,2,3], 2:[4,5,6]}, 8) ``` Can we draw inspiration from other APIs here like numpy/scipy/Matlab? I don't think any of those has such a state machine API: rather these effects are achieved through composition of many simple primitives. Is it intentional that I can do this: ```julia In [5]: Matrix.diag(1, 2, {'move':(1,-1)}, {0:3}) Out[5]: ⎡1 0⎤ ⎢ ⎥ ⎣0 3⎦ ``` It took me a couple of goes to get the indices right for that move. Is the coordinate system +/+ for upwards and to the right? That makes the horizontal direction alined with increasing indices and the vertical direction reversed. > I can't really imagine wanting to do something like this and I wouldn't want to try and understand code that was written this way. Wouldn't this example be better written as this: > ``` > diag({0: [7]+4*[0], -2:[1,2,3], 2:[4,5,6]}, 8) > ``` Either of the two gives out the same matrix as result, but in the former one we use keywords 'goto' and 'move' to indicate absolute position or relative motion whereas latter uses kerning matrices (allow only non-negative motion). > Is it intentional that I can do this: > ```julia > In [5]: Matrix.diag(1, 2, {'move':(1,-1)}, {0:3}) > Out[5]: > ⎡1 0⎤ > ⎢ ⎥ > ⎣0 3⎦ > ``` Yes, I think it should be this way cause it indicates the relative motion of the block `{0: 3}` to a step left and a step up. > Is the coordinate system +/+ for upwards and to the right? That makes the horizontal direction alined with increasing indices and the vertical direction reversed. The coordinate system we chose as of now: 1. If the key is `goto` we need to start filling from than position (index). 2. If the key is `move` and value `(x, y)` we'll relatively move the block x rows up and y cols right. This is the reason in order to move the block down we need to give a negative x. (This convention can be changed if required). @smichr Hope I'm correct with the conventions mentioned above, can you please crosscheck. > can you please crosscheck. yes, but I agree with @oscarbenjamin . I think we can get rid of the kerning. I've reset the code back to the one in which we didn't implement any functionality for `move` and `goto`. I find diag useful for creating block diagonal matrices: ``` In [1]: diag(ones(2), ones(2)) Out[1]: ⎡1 1 0 0⎤ ⎢ ⎥ ⎢1 1 0 0⎥ ⎢ ⎥ ⎢0 0 1 1⎥ ⎢ ⎥ ⎣0 0 1 1⎦ ``` Does this PR affect that? Also do you think there's a reasonable way of using the features here for banded block matrices? I just tried this Pr with: ``` In [2]: diag({-1:ones(2)}, ones(2)) --------------------------------------------------------------------------- TypeError Traceback (most recent call last) ``` > I find diag useful for creating block diagonal matrices: > In [1]: diag(ones(2), ones(2)) > Does this PR affect that? Nope, even now diag is useful for creating block diagonal matrices. > Also do you think there's a reasonable way of using the features here for banded block matrices? > I just tried this Pr with: > > ``` > In [2]: diag({-1:ones(2)}, ones(2)) > --------------------------------------------------------------------------- > TypeError Traceback (most recent call last) > ``` As of now we assumed that the values given in the dictionary can be anyone of lists, functions or a single value. If we implement it to take in matrices also as values...yes we'll be able to get banded block matrices. > As of now we assumed that the values given in the dictionary can be anyone of lists, functions or a single value. If we implement it to take in matrices also as values...yes we'll be able to get banded block matrices. I tried implementing it, but it's very confusing on how the matrix produced should look like. As of now, I think it's better not adding this functionality. ``` a = ones(2) assert diag({0:[1]*7, 3:a, -3:-a}) == Matrix([ [ 1, 0, 0, 1, 1, 0, 0], [ 0, 1, 0, 1, 1, 0, 0], [ 0, 0, 1, 0, 0, 1, 1], [-1, -1, 0, 1, 0, 1, 1], [-1, -1, 0, 0, 1, 0, 0], [ 0, 0, -1, -1, 0, 1, 0], [ 0, 0, -1, -1, 0, 0, 1]]) ``` pr pending > reasonable way of using the features here for banded block matrices? ```python >>> diag({-1:ones(2)}, ones(2)) Matrix([ [0, 0, 0, 0], [1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 1], [0, 0, 1, 1]]) >>> diag({-1:ones(2)}, {}, ones(2)) # restart on diag Matrix([ [0, 0, 0, 0], [1, 1, 0, 0], [1, 1, 1, 1], [0, 0, 1, 1]]) >>> diag({-1:ones(2)}, rows=7) Matrix([ [0, 0, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 1, 1, 0]]) ``` > it's very confusing I agree. It will be worth testing this for a while to make sure there are no corners left unchecked. This PR looks really, really complex to me, and I don't understand the API. I don't think we should not attempt to support banded block-matrices (i.e., a matrix off the diagonal) and function arguments (though I could be convinced otherwise, it looks really complicated right now). I would propose adding a `bands={...}` keyword-only argument and limit it to the form `{<band offset>: <number || list>}`. If someone wants to do complicated things with functions, use a function to create a matrix in the first place. For example, ``` def get_band(i,j): return j - i Matrix(5,5, lambda i,j: get_band(i,j)**2) ``` As a separate issue, the code formatting of the unit tests should be a separate PR so this one can focus on just new code. --------------------easier creation of banded matrices currently we have the `Matrix.diag` method which allows for easy creation of a single diagonal. To create a banded matrix is a little more difficult. This is the current docstring extract: ``` A given band off the diagonal can be made by padding with a vertical or horizontal "kerning" vector: >>> hpad = Matrix(0, 2, []) >>> vpad = Matrix(2, 0, []) >>> Matrix.diag(vpad, 1, 2, 3, hpad) + Matrix.diag(hpad, 4, 5, 6, vpad) Matrix([ [0, 0, 4, 0, 0], [0, 0, 0, 5, 0], [1, 0, 0, 0, 6], [0, 2, 0, 0, 0], [0, 0, 3, 0, 0]]) ``` And here's a suggestion of how it could be enhanced: ``` This can also be done by passing a dictionary giving the diagonal number and value: >>> Matrix.diag({0: 1, 1: 2}, rows=3, cols=4) Matrix([ [1, 2, 0, 0], [0, 1, 2, 0], [0, 0, 1, 2]]) If the values for the diagonal are not all the same they can be given as a) a list (and a check will be made that there are the right number present) or b) a 2-argument function that will compute the value from the row and column position or c) a single-argument function that will compute the value from the distance along the diagonal: >>> Matrix.diag({ ... -1: [-1, -2], ... 0: lambda i, j: i + 1, ... 1: lambda d: 2*d + 1}, ... rows=3, cols=4) ... Matrix([ [ 1, 1, 0, 0], [-1, 2, 3, 0], [ 0, -2, 3, 5]]) Note: it is also possible to create a diagonal matrix with a Piecewise function without using the diag method: >>> Matrix(4,6,lambda i,j: Piecewise((x, Eq(i, j)),(1, Eq(i - 1, j)), (0, True))) Matrix([ [x, 0, 0, 0, 0, 0], [1, x, 0, 0, 0, 0], [0, 1, x, 0, 0, 0], [0, 0, 1, x, 0, 0]]) >>> Matrix(5,5,lambda i,j: Piecewise((1, Eq(i + 2, j)), (0, True))) Matrix([ [0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]) >>> Matrix(5,5,lambda i,j: Piecewise((1, Eq(i - 2, j)), (0, True))) Matrix([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [1, 0, 0, 0, 0], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0]]) >>> Matrix(5,5,lambda i,j: Piecewise((1, Eq(5-1,i+j+2)),(0,True))) Matrix([ [0, 0, 1, 0, 0], [0, 1, 0, 0, 0], [1, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]) >>> Matrix(5,5,lambda i,j: Piecewise((1, Eq(5-1,i+j-2)),(0,True))) Matrix([ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 1], [0, 0, 0, 1, 0], [0, 0, 1, 0, 0]]) ``` ---------- I'm working on this. -------------------- </issues>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-16439

16,439

sympy/sympy

1.5

3729e1ba5a2afcfc3ceee7b98b07d5b57303f919

2019-03-25T17:57:37Z

diff --git a/sympy/physics/continuum_mechanics/beam.py b/sympy/physics/continuum_mechanics/beam.py index f4bca0cd9411..80c7b9adcc9b 100644 --- a/sympy/physics/continuum_mechanics/beam.py +++ b/sympy/physics/continuum_mechanics/beam.py @@ -13,6 +13,16 @@ from sympy.integrals import integrate from sympy.series import limit from sympy.plotting import plot, PlotGrid +from sympy.external import import_module +from sympy.utilities.decorator import doctest_depends_on +from sympy import lambdify +from sympy.core.compatibility import iterable + +matplotlib = import_module('matplotlib', __import__kwargs={'fromlist':['pyplot']}) +numpy = import_module('numpy', __import__kwargs={'fromlist':['linspace']}) + +__doctest_requires__ = {('Beam.plot_loading_results',): ['matplotlib']} + class Beam(object): """ @@ -1645,6 +1655,29 @@ def boundary_conditions(self): """ return self._boundary_conditions + def polar_moment(self): + """ + Returns the polar moment of area of the beam + about the X axis with respect to the centroid. + + Examples + ======== + + >>> from sympy.physics.continuum_mechanics.beam import Beam3D + >>> from sympy import symbols + >>> l, E, G, I, A = symbols('l, E, G, I, A') + >>> b = Beam3D(l, E, G, I, A) + >>> b.polar_moment() + 2*I + >>> I1 = [9, 15] + >>> b = Beam3D(l, E, G, I1, A) + >>> b.polar_moment() + 24 + """ + if not iterable(self.second_moment): + return 2*self.second_moment + return sum(self.second_moment) + def apply_load(self, value, start, order, dir="y"): """ This method adds up the force load to a particular beam object.

diff --git a/sympy/physics/continuum_mechanics/tests/test_beam.py b/sympy/physics/continuum_mechanics/tests/test_beam.py index 980bcb1d76ef..5299ce7c98c9 100644 --- a/sympy/physics/continuum_mechanics/tests/test_beam.py +++ b/sympy/physics/continuum_mechanics/tests/test_beam.py @@ -501,6 +501,7 @@ def test_Beam3D(): b.bc_deflection = [(0, [0, 0, 0]), (l, [0, 0, 0])] b.solve_slope_deflection() + assert b.polar_moment() == 2*I assert b.shear_force() == [0, -q*x, 0] assert b.bending_moment() == [0, 0, -m*x + q*x**2/2] expected_deflection = (x*(A*G*q*x**3/4 + A*G*x**2*(-l*(A*G*l*(l*q - 2*m) + @@ -540,6 +541,14 @@ def test_Beam3D(): assert b3.reaction_loads == {R1: -120, R2: -120, R3: -1350, R4: -2700} +def test_polar_moment_Beam3D(): + l, E, G, A, I1, I2 = symbols('l, E, G, A, I1, I2') + I = [I1, I2] + + b = Beam3D(l, E, G, I, A) + assert b.polar_moment() == I1 + I2 + + def test_parabolic_loads(): E, I, L = symbols('E, I, L', positive=True, real=True)

[ { "components": [ { "doc": "Returns the polar moment of area of the beam\nabout the X axis with respect to the centroid.\n\nExamples\n========\n\n>>> from sympy.physics.continuum_mechanics.beam import Beam3D\n>>> from sympy import symbols\n>>> l, E, G, I, A = symbols('l, E, G, I, A')\n>>> b = Beam...

[ "test_Beam3D", "test_polar_moment_Beam3D" ]

[ "test_Beam", "test_insufficient_bconditions", "test_statically_indeterminate", "test_beam_units", "test_variable_moment", "test_composite_beam", "test_point_cflexure", "test_remove_load", "test_apply_support", "test_max_shear_force", "test_max_bmoment", "test_max_deflection" ]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Function to calculate Polar moment of inertia of a 3D Beam  #### References to other Issues or PRs  fixes #16392 #### Brief description of what is fixed or changed New function in Beam/Beam3D #### Other comments Currently calculates polar moment only along x-axis #### Release Notes   * physics.continuum_mechanics * added a new function polar_moment()  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/physics/continuum_mechanics/beam.py] (definition of Beam3D.polar_moment:) def polar_moment(self): """Returns the polar moment of area of the beam about the X axis with respect to the centroid. Examples ======== >>> from sympy.physics.continuum_mechanics.beam import Beam3D >>> from sympy import symbols >>> l, E, G, I, A = symbols('l, E, G, I, A') >>> b = Beam3D(l, E, G, I, A) >>> b.polar_moment() 2*I >>> I1 = [9, 15] >>> b = Beam3D(l, E, G, I1, A) >>> b.polar_moment() 24""" [end of new definitions in sympy/physics/continuum_mechanics/beam.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> No function for calculating polar moment of inertia and section modulus in continuum_mechanics in beam.py There is currently no function to calculate polar moment of inertia and section modulus of the beam . Both of these quantities are important in further future works in this module. ---------- Can I work on this? Sure, feel free. Here the Beam is 2D, so along what axis should the polar moment be? Usually it is along the beam, right? @arooshiverma There is a separate class for 3D beams. Checkout from line no 1493. I think you'll have to calculate it in all 3 directions. Yeah got it. Will do it. -------------------- </issues>

c72f122f67553e1af930bac6c35732d2a0bbb776

sympy__sympy-16423

16,423

sympy/sympy

1.5

815be53c35580e119f864466095fb1d7ecd65f4f

2019-03-24T15:14:21Z

diff --git a/sympy/physics/quantum/commutator.py b/sympy/physics/quantum/commutator.py index 487dc923e9f5..94cd53a1f245 100644 --- a/sympy/physics/quantum/commutator.py +++ b/sympy/physics/quantum/commutator.py @@ -2,7 +2,7 @@ from __future__ import print_function, division -from sympy import S, Expr, Mul, Add +from sympy import S, Expr, Mul, Add, Pow from sympy.printing.pretty.stringpict import prettyForm from sympy.physics.quantum.dagger import Dagger @@ -117,6 +117,22 @@ def eval(cls, a, b): if a.compare(b) == 1: return S.NegativeOne*cls(b, a) + def _expand_pow(self, A, B, sign): + exp = A.exp + if not exp.is_integer or not exp.is_constant() or abs(exp) <= 1: + # nothing to do + return self + base = A.base + if exp.is_negative: + base = A.base**-1 + exp = -exp + comm = Commutator(base, B).expand(commutator=True) + + result = base**(exp - 1) * comm + for i in range(1, exp): + result += base**(exp - 1 - i) * comm * base**i + return sign*result.expand() + def _eval_expand_commutator(self, **hints): A = self.args[0] B = self.args[1] @@ -167,6 +183,12 @@ def _eval_expand_commutator(self, **hints): first = Mul(comm1, c) second = Mul(b, comm2) return Add(first, second) + elif isinstance(A, Pow): + # [A**n, C] -> A**(n - 1)*[A, C] + A**(n - 2)*[A, C]*A + ... + [A, C]*A**(n-1) + return self._expand_pow(A, B, 1) + elif isinstance(B, Pow): + # [A, C**n] -> C**(n - 1)*[C, A] + C**(n - 2)*[C, A]*C + ... + [C, A]*C**(n-1) + return self._expand_pow(B, A, -1) # No changes, so return self return self

diff --git a/sympy/physics/quantum/tests/test_commutator.py b/sympy/physics/quantum/tests/test_commutator.py index 021698740e04..a8aa1589b753 100644 --- a/sympy/physics/quantum/tests/test_commutator.py +++ b/sympy/physics/quantum/tests/test_commutator.py @@ -6,6 +6,7 @@ a, b, c = symbols('a,b,c') +n = symbols('n', integer=True) A, B, C, D = symbols('A,B,C,D', commutative=False) @@ -25,9 +26,17 @@ def test_commutator_identities(): assert Comm(A, B*C).expand(commutator=True) == Comm(A, B)*C + B*Comm(A, C) assert Comm(A*B, C*D).expand(commutator=True) == \ A*C*Comm(B, D) + A*Comm(B, C)*D + C*Comm(A, D)*B + Comm(A, C)*D*B + assert Comm(A, B**2).expand(commutator=True) == Comm(A, B)*B + B*Comm(A, B) + assert Comm(A**2, C**2).expand(commutator=True) == \ + Comm(A*B, C*D).expand(commutator=True).replace(B, A).replace(D, C) == \ + A*C*Comm(A, C) + A*Comm(A, C)*C + C*Comm(A, C)*A + Comm(A, C)*C*A + assert Comm(A, C**-2).expand(commutator=True) == \ + Comm(A, (1/C)*(1/D)).expand(commutator=True).replace(D, C) assert Comm(A + B, C + D).expand(commutator=True) == \ Comm(A, C) + Comm(A, D) + Comm(B, C) + Comm(B, D) assert Comm(A, B + C).expand(commutator=True) == Comm(A, B) + Comm(A, C) + assert Comm(A**n, B).expand(commutator=True) == Comm(A**n, B) + e = Comm(A, Comm(B, C)) + Comm(B, Comm(C, A)) + Comm(C, Comm(A, B)) assert e.doit().expand() == 0 @@ -64,3 +73,8 @@ def test_eval_commutator(): assert Comm(F, T).doit() == -1 assert Comm(T, F).doit() == 1 assert Comm(B, T).doit() == B*T - T*B + assert Comm(F**2, B).expand(commutator=True).doit() == 0 + assert Comm(F**2, T).expand(commutator=True).doit() == -2*F + assert Comm(F, T**2).expand(commutator=True).doit() == -2*T + assert Comm(T**2, F).expand(commutator=True).doit() == 2*T + assert Comm(T**2, F**3).expand(commutator=True).doit() == 2*F*T*F + 2*F**2*T + 2*T*F**2

[ { "components": [ { "doc": "", "lines": [ 120, 134 ], "name": "Commutator._expand_pow", "signature": "def _expand_pow(self, A, B, sign):", "type": "function" } ], "file": "sympy/physics/quantum/commutator.py" } ]

[ "test_commutator_identities" ]

[ "test_commutator", "test_commutator_dagger" ]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Handle Pow in Commutator expansion. #### Brief description of what is fixed or changed Handle expansion of commutators like ``` [A**2, C] = [A*A, C] -> A*[A, C] + [A, C]*A ``` but for arbitrary integer exponent. #### Release Notes   * physics.quantum * Pow expressions handled in Commutator expansion  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/physics/quantum/commutator.py] (definition of Commutator._expand_pow:) def _expand_pow(self, A, B, sign): [end of new definitions in sympy/physics/quantum/commutator.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c72f122f67553e1af930bac6c35732d2a0bbb776

astropy__astropy-8517

8,517

astropy/astropy

3.1

cfe7616626c00c3dc7a912c1f432c00d52dba8b0

2019-03-21T16:49:54Z

diff --git a/CHANGES.rst b/CHANGES.rst index 9cc0c28c2d96..5d5bf3f541a2 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -10,6 +10,9 @@ astropy.config astropy.constants ^^^^^^^^^^^^^^^^^ +- The version of constants can be specified via ScienceState in a way + that ``constants`` and ``units`` will be consistent. [#8517] + astropy.convolution ^^^^^^^^^^^^^^^^^^^ diff --git a/astropy/__init__.py b/astropy/__init__.py index ab8d1736ad27..edfea0da948d 100644 --- a/astropy/__init__.py +++ b/astropy/__init__.py @@ -157,6 +157,80 @@ class Conf(_config.ConfigNamespace): conf = Conf() + +# Define a base ScienceState for configuring constants and units +from .utils.state import ScienceState +class base_constants_version(ScienceState): + """ + Base class for the real version-setters below + """ + _value = 'test' + + _versions = dict(test='test') + + @classmethod + def validate(cls, value): + if value not in cls._versions: + raise ValueError('Must be one of {}' + .format(list(cls._versions.keys()))) + return cls._versions[value] + + @classmethod + def set(cls, value): + """ + Set the current constants value. + """ + import sys + if 'astropy.units' in sys.modules: + raise RuntimeError('astropy.units is already imported') + if 'astropy.constants' in sys.modules: + raise RuntimeError('astropy.constants is already imported') + + class _Context: + def __init__(self, parent, value): + self._value = value + self._parent = parent + + def __enter__(self): + pass + + def __exit__(self, type, value, tb): + self._parent._value = self._value + + def __repr__(self): + return ('<ScienceState {0}: {1!r}>' + .format(self._parent.__name__, self._parent._value)) + + ctx = _Context(cls, cls._value) + value = cls.validate(value) + cls._value = value + return ctx + + +class physical_constants(base_constants_version): + """ + The version of physical constants to use + """ + # Maintainers: update when new constants are added + _value = 'codata2014' + + _versions = dict(codata2018='codata2018', codata2014='codata2014', + codata2010='codata2010', astropyconst40='codata2018', + astropyconst20='codata2014', astropyconst13='codata2010') + + +class astronomical_constants(base_constants_version): + """ + The version of astronomical constants to use + """ + # Maintainers: update when new constants are added + _value = 'iau2015' + + _versions = dict(iau2015='iau2015', iau2012='iau2012', + astropyconst40='iau2015', astropyconst20='iau2015', + astropyconst13='iau2012') + + # Create the test() function from .tests.runner import TestRunner test = TestRunner.make_test_runner_in(__path__[0]) @@ -320,7 +394,8 @@ def online_help(query): __dir_inc__ = ['__version__', '__githash__', '__minimum_numpy_version__', '__bibtex__', 'test', 'log', 'find_api_page', 'online_help', - 'online_docs_root', 'conf'] + 'online_docs_root', 'conf', 'physical_constants', + 'astronomical_constants'] from types import ModuleType as __module_type__ diff --git a/astropy/constants/__init__.py b/astropy/constants/__init__.py index 65350120f9d9..7607e642de77 100644 --- a/astropy/constants/__init__.py +++ b/astropy/constants/__init__.py @@ -13,21 +13,21 @@ <Quantity 0.510998927603161 MeV> """ +import warnings from contextlib import contextmanager from astropy.utils import find_current_module # Hack to make circular imports with units work -try: - from astropy import units - del units -except ImportError: - pass +from astropy import units +del units +# These lines import some namespaces into the top level from .constant import Constant, EMConstant # noqa from . import si # noqa from . import cgs # noqa -from . import codata2014, iau2015 # noqa +from .config import codata, iaudata + from . import utils as _utils # for updating the constants module docstring @@ -38,9 +38,11 @@ '========== ============== ================ =========================', ] -# NOTE: Update this when default changes. -_utils._set_c(codata2014, iau2015, find_current_module(), - not_in_module_only=True, doclines=_lines, set_class=True) +# Catch warnings about "already has a definition in the None system" +with warnings.catch_warnings(): + warnings.filterwarnings('ignore', 'Constant .*already has a definition') + _utils._set_c(codata, iaudata, find_current_module(), + not_in_module_only=False, doclines=_lines, set_class=True) _lines.append(_lines[1]) @@ -65,38 +67,42 @@ def set_enabled_constants(modname): """ # Re-import here because these were deleted from namespace on init. + import importlib import warnings from astropy.utils import find_current_module from . import utils as _utils - # NOTE: Update this when default changes. - if modname == 'astropyconst13': - from .astropyconst13 import codata2010 as codata - from .astropyconst13 import iau2012 as iaudata - else: - raise ValueError( - 'Context manager does not currently handle {}'.format(modname)) + try: + modmodule = importlib.import_module('.constants.' + modname, 'astropy') + codata_context = modmodule.codata + iaudata_context = modmodule.iaudata + except ImportError as exc: + exc.args += ('Context manager does not currently handle {}' + .format(modname),) + raise module = find_current_module() # Ignore warnings about "Constant xxx already has a definition..." with warnings.catch_warnings(): - warnings.simplefilter('ignore') - _utils._set_c(codata, iaudata, module, + warnings.filterwarnings('ignore', + 'Constant .*already has a definition') + _utils._set_c(codata_context, iaudata_context, module, not_in_module_only=False, set_class=True) try: yield finally: with warnings.catch_warnings(): - warnings.simplefilter('ignore') - # NOTE: Update this when default changes. - _utils._set_c(codata2014, iau2015, module, + warnings.filterwarnings('ignore', + 'Constant .*already has a definition') + _utils._set_c(codata, iaudata, module, not_in_module_only=False, set_class=True) # Clean up namespace del find_current_module +del warnings del contextmanager del _utils del _lines diff --git a/astropy/constants/astropyconst13.py b/astropy/constants/astropyconst13.py index 4e19a0f883d5..b22fca4ccd67 100644 --- a/astropy/constants/astropyconst13.py +++ b/astropy/constants/astropyconst13.py @@ -8,7 +8,10 @@ from . import utils as _utils from . import codata2010, iau2012 -_utils._set_c(codata2010, iau2012, find_current_module()) +codata = codata2010 +iaudata = iau2012 + +_utils._set_c(codata, iaudata, find_current_module()) # Clean up namespace del find_current_module diff --git a/astropy/constants/astropyconst20.py b/astropy/constants/astropyconst20.py index 5a04ec7d6196..050db5d0af16 100644 --- a/astropy/constants/astropyconst20.py +++ b/astropy/constants/astropyconst20.py @@ -7,7 +7,11 @@ from . import utils as _utils from . import codata2014, iau2015 -_utils._set_c(codata2014, iau2015, find_current_module()) + +codata = codata2014 +iaudata = iau2015 + +_utils._set_c(codata, iaudata, find_current_module()) # Clean up namespace del find_current_module diff --git a/astropy/constants/cgs.py b/astropy/constants/cgs.py index adca1b3411c3..0c7aeb536765 100644 --- a/astropy/constants/cgs.py +++ b/astropy/constants/cgs.py @@ -3,14 +3,13 @@ Astronomical and physics constants in cgs units. See :mod:`astropy.constants` for a complete listing of constants defined in Astropy. """ - import itertools from .constant import Constant -from . import codata2014, iau2015 +from .config import codata, iaudata -for _nm, _c in itertools.chain(sorted(vars(codata2014).items()), - sorted(vars(iau2015).items())): +for _nm, _c in itertools.chain(sorted(vars(codata).items()), + sorted(vars(iaudata).items())): if (isinstance(_c, Constant) and _c.abbrev not in locals() - and _c.system in ['esu', 'gauss', 'emu']): + and _c.system in ['esu', 'gauss', 'emu']): locals()[_c.abbrev] = _c diff --git a/astropy/constants/config.py b/astropy/constants/config.py new file mode 100644 index 000000000000..c163b820ec98 --- /dev/null +++ b/astropy/constants/config.py @@ -0,0 +1,14 @@ +# Licensed under a 3-clause BSD style license - see LICENSE.rst +""" +Configures the codata and iaudata used, possibly using user configuration. +""" +# Note: doing this in __init__ causes import problems with units, +# as si.py and cgs.py have to import the result. +import importlib +import astropy + +phys_version = astropy.physical_constants.get() +astro_version = astropy.astronomical_constants.get() + +codata = importlib.import_module('.constants.' + phys_version, 'astropy') +iaudata = importlib.import_module('.constants.' + astro_version, 'astropy') diff --git a/astropy/constants/si.py b/astropy/constants/si.py index 65e5a2d13eb8..c8f83a841110 100644 --- a/astropy/constants/si.py +++ b/astropy/constants/si.py @@ -3,16 +3,13 @@ Astronomical and physics constants in SI units. See :mod:`astropy.constants` for a complete listing of constants defined in Astropy. """ - - - import itertools from .constant import Constant -from . import codata2014, iau2015 +from .config import codata, iaudata -for _nm, _c in itertools.chain(sorted(vars(codata2014).items()), - sorted(vars(iau2015).items())): +for _nm, _c in itertools.chain(sorted(vars(codata).items()), + sorted(vars(iaudata).items())): if (isinstance(_c, Constant) and _c.abbrev not in locals() - and _c.system == 'si'): + and _c.system == 'si'): locals()[_c.abbrev] = _c diff --git a/docs/constants/index.rst b/docs/constants/index.rst index de4e4709f299..d31aa1656a40 100644 --- a/docs/constants/index.rst +++ b/docs/constants/index.rst @@ -118,9 +118,57 @@ Union (IAU) are collected in modules with names like ``iau2012`` or ``iau2015``: Reference = IAU 2015 Resolution B 3 The astronomical and physical constants are combined into modules with -names like ``astropyconst13`` and ``astropyconst20``. To temporarily set -constants to an older version (e.g., for regression testing), a context -manager is available as follows: +names like ``astropyconst13`` and ``astropyconst20`` for different versions. +However, importing these prior version modules directly will lead to +inconsistencies with other subpackages that have already imported +`astropy.constants`. Notably, `astropy.units` will have already used +the default version of constants. When using prior versions of the constants +in this manner, quantities should be constructed with constants instead of units. + +To ensure consistent use of a prior version of constants in other Astropy +packages (such as `astropy.units`) that import constants, the physical and +astronomical constants versions should be set via ScienceState classes. +These must be set before the first import of either `astropy.constants` or +`astropy.units`. For example, you can use the CODATA2010 physical constants and the +IAU 2012 astronomical constants: + + >>> from astropy import physical_constants, astronomical_constants + >>> physical_constants.set('codata2010') # doctest: +SKIP + <ScienceState physical_constants: 'codata2010'> + >>> physical_constants.get() # doctest: +SKIP + 'codata2010' + >>> astronomical_constants.set('iau2012') # doctest: +SKIP + <ScienceState astronomical_constants: 'iau2012'> + >>> astronomical_constants.get() # doctest: +SKIP + 'iau2012' + +Then all other packages that import `astropy.constants` will self-consistently +initialize with that prior version of constants. + +The versions may also be set using values referring to the version modules: + + >>> from astropy import physical_constants, astronomical_constants + >>> physical_constants.set('astropyconst13') # doctest: +SKIP + <ScienceState physical_constants: 'codata2010'> + >>> physical_constants.get() # doctest: +SKIP + 'codata2010' + >>> astronomical_constants.set('astropyconst13') # doctest: +SKIP + <ScienceState astronomical_constants: 'iau2012'> + >>> astronomical_constants.get() # doctest: +SKIP + 'iau2012' + +If either `astropy.constants` or `astropy.units` have already been imported, a +``RuntimeError`` will be raised. + + >>> import astropy.units + >>> from astropy import physical_constants, astronomical_constants + >>> astronomical_constants.set('astropyconst13') + Traceback (most recent call last): + ... + RuntimeError: astropy.units is already imported + +To temporarily set constants to an older version (e.g., +for regression testing), a context manager is available, as follows: >>> from astropy import constants as const >>> with const.set_enabled_constants('astropyconst13'): @@ -137,11 +185,10 @@ manager is available as follows: Unit = J s Reference = CODATA 2014 -.. warning:: +The context manager may be used at any time in a Python session, but it +uses the prior version only for `astropy.constants`, and not for any +other subpackage such as `astropy.units`. - Units such as ``u.M_sun`` will use the current version of the - corresponding constant. When using prior versions of the constants, - quantities should be constructed with constants instead of units. .. note that if this section gets too long, it should be moved to a separate doc page - see the top of performance.inc.rst for the instructions on how to diff --git a/docs/units/constants_versions.rst b/docs/units/constants_versions.rst new file mode 100644 index 000000000000..4663b3257f24 --- /dev/null +++ b/docs/units/constants_versions.rst @@ -0,0 +1,29 @@ +Using prior versions of constants +********************************* + +By default, `astropy.units` are initialized upon first import to use +the current versions of `astropy.constants`. For units to initialize +properly to a prior version of constants, the constants versions must +be set before the first import of `astropy.units` or `astropy.constants`. + +This is accomplished using ScienceState classes in the top-level package. +Setting the prior versions at the start of a Python session will allow +consistent units, as follows: + +>>> import astropy +>>> astropy.physical_constants.set('codata2010') # doctest: +SKIP +<ScienceState physical_constants: 'codata2010'> +>>> astropy.astronomical_constants.set('iau2012') # doctest: +SKIP +<ScienceState astronomical_constants: 'iau2012'> +>>> import astropy.units as u +>>> import astropy.constants as const +>>> (const.M_sun / u.M_sun).to(u.dimensionless_unscaled) - 1 # doctest: +SKIP +<Quantity 0.> +>>> const.M_sun # doctest: +SKIP + Name = Solar mass + Value = 1.9891e+30 + Uncertainty = 5e+25 + Unit = kg + Reference = Allen's Astrophysical Quantities 4th Ed. + +If `astropy.units` has already been imported, a RuntimeError is raised. diff --git a/docs/units/index.rst b/docs/units/index.rst index 4267de423490..82a7d412d664 100644 --- a/docs/units/index.rst +++ b/docs/units/index.rst @@ -165,6 +165,7 @@ Using `astropy.units` logarithmic_units format equivalencies + constants_versions conversion See Also

diff --git a/astropy/constants/tests/test_prior_version.py b/astropy/constants/tests/test_prior_version.py index 5d13c66a7b98..c7f54ef75b60 100644 --- a/astropy/constants/tests/test_prior_version.py +++ b/astropy/constants/tests/test_prior_version.py @@ -163,6 +163,6 @@ def test_context_manager(): assert const.h.value == 6.626070040e-34 # CODATA2014 - with pytest.raises(ValueError): + with pytest.raises(ImportError): with const.set_enabled_constants('notreal'): const.h diff --git a/astropy/constants/tests/test_sciencestate.py b/astropy/constants/tests/test_sciencestate.py new file mode 100644 index 000000000000..1fa32b6909e1 --- /dev/null +++ b/astropy/constants/tests/test_sciencestate.py @@ -0,0 +1,21 @@ +import pytest + +from astropy import physical_constants, astronomical_constants +import astropy.constants as const + + +def test_version_match(): + pversion = physical_constants.get() + refpversion = const.h.__class__.__name__.lower() + assert pversion == refpversion + aversion = astronomical_constants.get() + refaversion = const.M_sun.__class__.__name__.lower() + assert aversion == refaversion + + +def test_previously_imported(): + with pytest.raises(RuntimeError): + physical_constants.set('codata2018') + + with pytest.raises(RuntimeError): + astronomical_constants.set('iau2015')

diff --git a/CHANGES.rst b/CHANGES.rst index 9cc0c28c2d96..5d5bf3f541a2 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -10,6 +10,9 @@ astropy.config astropy.constants ^^^^^^^^^^^^^^^^^ +- The version of constants can be specified via ScienceState in a way + that ``constants`` and ``units`` will be consistent. [#8517] + astropy.convolution ^^^^^^^^^^^^^^^^^^^ diff --git a/docs/constants/index.rst b/docs/constants/index.rst index de4e4709f299..d31aa1656a40 100644 --- a/docs/constants/index.rst +++ b/docs/constants/index.rst @@ -118,9 +118,57 @@ Union (IAU) are collected in modules with names like ``iau2012`` or ``iau2015``: Reference = IAU 2015 Resolution B 3 The astronomical and physical constants are combined into modules with -names like ``astropyconst13`` and ``astropyconst20``. To temporarily set -constants to an older version (e.g., for regression testing), a context -manager is available as follows: +names like ``astropyconst13`` and ``astropyconst20`` for different versions. +However, importing these prior version modules directly will lead to +inconsistencies with other subpackages that have already imported +`astropy.constants`. Notably, `astropy.units` will have already used +the default version of constants. When using prior versions of the constants +in this manner, quantities should be constructed with constants instead of units. + +To ensure consistent use of a prior version of constants in other Astropy +packages (such as `astropy.units`) that import constants, the physical and +astronomical constants versions should be set via ScienceState classes. +These must be set before the first import of either `astropy.constants` or +`astropy.units`. For example, you can use the CODATA2010 physical constants and the +IAU 2012 astronomical constants: + + >>> from astropy import physical_constants, astronomical_constants + >>> physical_constants.set('codata2010') # doctest: +SKIP + <ScienceState physical_constants: 'codata2010'> + >>> physical_constants.get() # doctest: +SKIP + 'codata2010' + >>> astronomical_constants.set('iau2012') # doctest: +SKIP + <ScienceState astronomical_constants: 'iau2012'> + >>> astronomical_constants.get() # doctest: +SKIP + 'iau2012' + +Then all other packages that import `astropy.constants` will self-consistently +initialize with that prior version of constants. + +The versions may also be set using values referring to the version modules: + + >>> from astropy import physical_constants, astronomical_constants + >>> physical_constants.set('astropyconst13') # doctest: +SKIP + <ScienceState physical_constants: 'codata2010'> + >>> physical_constants.get() # doctest: +SKIP + 'codata2010' + >>> astronomical_constants.set('astropyconst13') # doctest: +SKIP + <ScienceState astronomical_constants: 'iau2012'> + >>> astronomical_constants.get() # doctest: +SKIP + 'iau2012' + +If either `astropy.constants` or `astropy.units` have already been imported, a +``RuntimeError`` will be raised. + + >>> import astropy.units + >>> from astropy import physical_constants, astronomical_constants + >>> astronomical_constants.set('astropyconst13') + Traceback (most recent call last): + ... + RuntimeError: astropy.units is already imported + +To temporarily set constants to an older version (e.g., +for regression testing), a context manager is available, as follows: >>> from astropy import constants as const >>> with const.set_enabled_constants('astropyconst13'): @@ -137,11 +185,10 @@ manager is available as follows: Unit = J s Reference = CODATA 2014 -.. warning:: +The context manager may be used at any time in a Python session, but it +uses the prior version only for `astropy.constants`, and not for any +other subpackage such as `astropy.units`. - Units such as ``u.M_sun`` will use the current version of the - corresponding constant. When using prior versions of the constants, - quantities should be constructed with constants instead of units. .. note that if this section gets too long, it should be moved to a separate doc page - see the top of performance.inc.rst for the instructions on how to diff --git a/docs/units/constants_versions.rst b/docs/units/constants_versions.rst new file mode 100644 index 000000000000..4663b3257f24 --- /dev/null +++ b/docs/units/constants_versions.rst @@ -0,0 +1,29 @@ +Using prior versions of constants +********************************* + +By default, `astropy.units` are initialized upon first import to use +the current versions of `astropy.constants`. For units to initialize +properly to a prior version of constants, the constants versions must +be set before the first import of `astropy.units` or `astropy.constants`. + +This is accomplished using ScienceState classes in the top-level package. +Setting the prior versions at the start of a Python session will allow +consistent units, as follows: + +>>> import astropy +>>> astropy.physical_constants.set('codata2010') # doctest: +SKIP +<ScienceState physical_constants: 'codata2010'> +>>> astropy.astronomical_constants.set('iau2012') # doctest: +SKIP +<ScienceState astronomical_constants: 'iau2012'> +>>> import astropy.units as u +>>> import astropy.constants as const +>>> (const.M_sun / u.M_sun).to(u.dimensionless_unscaled) - 1 # doctest: +SKIP +<Quantity 0.> +>>> const.M_sun # doctest: +SKIP + Name = Solar mass + Value = 1.9891e+30 + Uncertainty = 5e+25 + Unit = kg + Reference = Allen's Astrophysical Quantities 4th Ed. + +If `astropy.units` has already been imported, a RuntimeError is raised. diff --git a/docs/units/index.rst b/docs/units/index.rst index 4267de423490..82a7d412d664 100644 --- a/docs/units/index.rst +++ b/docs/units/index.rst @@ -165,6 +165,7 @@ Using `astropy.units` logarithmic_units format equivalencies + constants_versions conversion See Also

[ { "components": [ { "doc": "Base class for the real version-setters below", "lines": [ 163, 207 ], "name": "base_constants_version", "signature": "class base_constants_version(ScienceState):", "type": "class" }, { "doc...

[ "astropy/constants/tests/test_prior_version.py::test_c", "astropy/constants/tests/test_prior_version.py::test_h", "astropy/constants/tests/test_prior_version.py::test_e", "astropy/constants/tests/test_prior_version.py::test_g0", "astropy/constants/tests/test_prior_version.py::test_b_wien", "astropy/consta...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Set constants version via ScienceState classes Fixes #6948 Add ScienceState classes for `astropy.constants` versions, to allow a user to set constants versions before importing units or constants. Then when the user does `import astropy.units as u`, the user-specified versions of constants will initialize units. EDIT: removed "work in progress" warnings EDIT: renamed to use ScienceState instead of config files ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in astropy/__init__.py] (definition of base_constants_version:) class base_constants_version(ScienceState): """Base class for the real version-setters below""" (definition of base_constants_version.validate:) def validate(cls, value): (definition of base_constants_version.set:) def set(cls, value): """Set the current constants value.""" (definition of base_constants_version.set._Context:) class _Context: (definition of base_constants_version.set._Context.__init__:) def __init__(self, parent, value): (definition of base_constants_version.set._Context.__enter__:) def __enter__(self): (definition of base_constants_version.set._Context.__exit__:) def __exit__(self, type, value, tb): (definition of base_constants_version.set._Context.__repr__:) def __repr__(self): (definition of physical_constants:) class physical_constants(base_constants_version): """The version of physical constants to use""" (definition of astronomical_constants:) class astronomical_constants(base_constants_version): """The version of astronomical constants to use""" [end of new definitions in astropy/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Make units be consistent with versioned constants This motivation for this issue is fixing a subtle but important inconsistency that can now appear because constants are versioned (new feature in v2.0). The basic problem is that some units are effectively tied to constants. For example `units.solMass` exists, but so does `constants.M_sun`. Right now with the default units they are consistent, but *if* someone uses the constant versioning machinery to update e.g. M_sun, they become inconsistent. There are a couple possible fixes here: * Tie the units to the constant values so that if a particular constant is set as the "current" version, the unit is assumed to have that value (I think that is more "right" but probably requires subtle and/or major changes to `units`). * Make unit conversion factors versionable, and provide helper functions or just instructions for how to sync them up (possibly easier, but means manual intervention is required). ---------- This is somewhat tricky, as unit definitions cascade down - one would effectively need the ability to reload `units` (or whole of astropy?). And of course even before that to reload `constants` itself. It may be easier to have a configuration item that states which constants are loaded by default (now: `codata2014`, `iau2015`). I am going to try the suggestion from @mhvk to make a configuration item for the versions of constants that are loaded when `units` or `constants` are first imported. Shooting for 3.2 which means having a PR open by April 5th, 2019. -------------------- </issues>

12a4d64093b833e198b2736d3cff817a9b286efc

joke2k__faker-930

930

joke2k/faker

null

eb7d9c838cd297c70730c43f2728ce86fe7320d9

2019-03-20T16:04:43Z

diff --git a/faker/providers/company/nl_NL/__init__.py b/faker/providers/company/nl_NL/__init__.py new file mode 100644 index 0000000000..6799303495 --- /dev/null +++ b/faker/providers/company/nl_NL/__init__.py @@ -0,0 +1,109 @@ +# coding=utf-8 + +from __future__ import unicode_literals +from .. import Provider as CompanyProvider + + +class Provider(CompanyProvider): + + formats = ( + '{{last_name}} {{company_suffix}}', + '{{last_name}} & {{last_name}}', + '{{company_prefix}} {{last_name}}', + '{{large_company}}', + ) + + company_prefixes = ( + 'Stichting', 'Koninklijke', 'Royal', + ) + + company_suffixes = ( + 'BV', 'NV', 'Groep', + ) + + # Source: https://www.mt.nl/management/reputatie/mt-500-2018-de-lijst/559930 + large_companies = ( + 'Shell', 'Coolblue', 'ASML', 'Ahold', 'Tata Steel', 'KLM', 'Bol.com', 'BP Nederland', 'De Efteling', 'Eneco', + 'De Persgroep', 'ING', 'Royal HaskoningDHV', 'Randstad', 'Google', 'Ikea', 'Rockwool', 'BAM', 'Achmea', + 'Damen Shipyard', 'ABN Amro', 'Remeha Group', 'TenneT', 'Coca-Cola', 'Van Leeuwen Buizen', 'Wavin', 'Rabobank', + 'AkzoNobel', 'Arcadis', 'AFAS', 'Cisco', 'DAF Trucks', 'DHL', 'Hanos', 'Boon Edam', 'BMW Nederland', + 'The Greenery', 'Dutch Flower Group', 'Koninklijke Mosa', 'Yacht', 'Rituals', 'Microsoft', 'Esso', + '3W Vastgoed', 'Deloitte', 'Corio', 'Voortman Steel Group', 'Agrifirm', 'Makro Nederland', + 'Nederlandse Publieke Omroep', 'De Alliantie', 'Heijmans', 'McDonalds', 'ANWB', 'Mediamarkt', 'Kruidvat' + 'Van Merksteijn Steel', 'Dura Vermeer', 'Alliander', 'Unilever', 'Enexis', 'Berenschot', 'Jumbo', + 'Technische Unie', 'Havenbedrijf Rotterdam', 'Ballast Nedam', 'RTL Nederland', 'Talpa Media', + 'Blauwhoed Vastgoed', 'DSM', 'Ymere', 'Witteveen+Bos', 'NS', 'Action', 'FloraHolland', 'Heineken', 'Nuon', 'EY', + 'Dow Benelux', 'Bavaria', 'Schiphol', 'Holland Casino', 'Binck bank', 'BDO', 'HEMA', 'Alphabet Nederland', + 'Croon Elektrotechniek', 'ASR Vastgoed ontwikkeling', 'PwC', 'Mammoet', 'KEMA', 'IBM', 'A.S. Watson', + 'KPMG', 'VodafoneZiggo', 'YoungCapital', 'Triodos Bank', 'Aviko', 'AgruniekRijnvallei', 'Heerema', 'Accenture', + 'Aegon', 'NXP', 'Breman Installatiegroep', 'Movares Groep', 'Q-Park', 'FleuraMetz', 'Sanoma', + 'Bakker Logistiek', 'VDL Group', 'Bayer', 'Boskalis', 'Nutreco', 'Dell', 'Brunel', 'Exact', 'Manpower', + 'Essent', 'Canon', 'ONVZ Zorgverzekeraar', 'Telegraaf Media Group', 'Nationale Nederlanden', 'Andus Group', + 'Den Braven Group', 'ADP', 'ASR', 'ArboNed', 'Plieger', 'De Heus Diervoeders', 'USG People', 'Bidvest Deli XL', + 'Apollo Vredestein', 'Tempo-Team', 'Trespa', 'Janssen Biologics', 'Starbucks', 'PostNL', 'Vanderlande', + 'FrieslandCampina', 'Constellium', 'Huisman', 'Abbott', 'Koninklijke Boom Uitgevers', 'Bosch Rexroth', 'BASF', + 'Audax', 'VolkerWessels', 'Hunkemöller', 'Athlon Car Lease', 'DSW Zorgverzekeraar', 'Mars', + 'De Brauw Blackstone Westbroek', 'NDC Mediagroep', 'Bluewater', 'Stedin', 'Feenstra', + 'Wuppermann Staal Nederland', 'Kramp', 'SABIC', 'Iv-Groep', 'Bejo Zaden', 'Wolters Kluwer', 'Nyrstar holding', + 'Adecco', 'Tauw', 'Robeco', 'Eriks', 'Allianz Nederland Groep', 'Driessen', 'Burger King', 'Lekkerland', + 'Van Lanschot', 'Brocacef', 'Bureau Veritas', 'Relx', 'Pathé Bioscopen', 'Bosal', + 'Ardagh Group', 'Maandag', 'Inalfa', 'Atradius', 'Capgemini', 'Greenchoice', 'Q8 (Kuwait Petroleum Europe)', + 'ASM International', 'Van der Valk', 'Delta Lloyd', 'GlaxoSmithKline', 'ABB', + 'Fabory, a Grainger company', 'Veen Bosch & Keuning Uitgeversgroep', 'CZ', 'Plus', 'RET Rotterdam', + 'Loyens & Loeff', 'Holland Trading', 'Archer Daniels Midland Nederland', 'Ten Brinke', 'NAM', 'DAS', + 'Samsung Electronics Benelux', 'Koopman International', 'TUI', 'Lannoo Meulenhoff', 'AC Restaurants', + 'Stage Entertainment', 'Acer', 'HDI Global SE', 'Detailresult', 'Nestle', 'GVB Amsterdam', 'Dekamarkt', 'Dirk', + 'MSD', 'Arriva', 'Baker Tilly Berk', 'SBM Offshore', 'TomTom', 'Fujifilm', 'B&S', 'BCC', 'Gasunie', + 'Oracle Nederland', 'Astellas Pharma', 'SKF', 'Woningstichting Eigen Haard', 'Rijk Zwaan', 'Chubb', 'Fugro', + 'Total', 'Rochdale', 'ASVB', 'Atos', 'Acomo', 'KPN', 'Van Drie Group', 'Olympia uitzendbureau', + 'Bacardi Nederland', 'JMW Horeca Uitzendbureau', 'Warner Bros/Eyeworks', 'Aalberts Industries', 'SNS Bank', + 'Amtrada Holding', 'VGZ', 'Grolsch', 'Office Depot', 'De Rijke Group', 'Bovemij Verzekeringsgroep', + 'Coop Nederland', 'Eaton Industries', 'ASN', 'Yara Sluiskil', 'HSF Logistics', 'Fokker', 'Deutsche Bank', + 'Sweco', 'Univé Groep', 'Koninklijke Wagenborg', 'Strukton', 'Conclusion', 'Philips', 'In Person', + 'Fluor', 'Vroegop-Windig', 'ArboUnie', 'Centraal Boekhuis', 'Siemens', 'Connexxion', 'Fujitsu', 'Consolid', + 'AVR Afvalverwerking', 'Brabant Alucast', 'Centric', 'Havensteder', 'Novartis', 'Booking.com', 'Menzis', + 'Frankort & Koning Groep', 'Jan de Rijk', 'Brand Loyalty Group', 'Ohra Verzekeringen', 'Terberg Group', + 'Cloetta', 'Holland & Barrett', 'Enza Zaden', 'VION', 'Woonzorg Nederland', + 'T-Mobile', 'Crucell', 'NautaDutilh', 'BNP Paribas', 'NIBC Bank', 'VastNed', 'CCV Holland', + 'IHC Merwede', 'Neways', 'NSI N.V.', 'Deen', 'Accor', 'HTM', 'ITM Group', 'Ordina', 'Dümmen Orange', 'Optiver', + 'Zara', 'L\'Oreal Nederland B.V.', 'Vinci Energies', 'Suit Supply Topco', 'Sita', 'Vos Logistics', + 'Altran', 'St. Clair', 'BESI', 'Fiat Chrysler Automobiles', 'UPS', 'Jacobs', 'Emté', 'TBI', 'De Bijenkorf', + 'Aldi Nederland', 'Van Wijnen', 'Vitens', 'De Goudse Verzekeringen', 'SBS Broadcasting', + 'Sandd', 'Omron', 'Sogeti', 'Alfa Accountants & Adviseurs', 'Harvey Nash', 'Stork', 'Glencore Grain', + 'Meijburg & Co', 'Honeywell', 'Meyn', 'Ericsson Telecommunicatie', 'Hurks', 'Mitsubishi', 'GGN', + 'CGI Nederland', 'Staples Nederland', 'Denkavit International', 'Ecorys', 'Rexel Nederland', + 'A. Hakpark', 'DuPont Nederland', 'CBRE Group', 'Bolsius', 'Marel', 'Metro', + 'Flynth Adviseurs en Accountants', 'Kropman Installatietechniek', 'Kuijpers', 'Medtronic', 'Cefetra', + 'Simon Loos', 'Citadel Enterprises', 'Intergamma', 'Ceva Logistics', 'Beter Bed', 'Subway', 'Gamma', 'Karwei' + 'Varo Energy', 'APM Terminals', 'Center Parcs', 'Brenntag Nederland', 'NFI', 'Hoogvliet', + 'Van Gansewinkel', 'Nedap', 'Blokker', 'Perfetti Van Melle', 'Vestia', 'Kuehne + Nagel Logistics', + 'Rensa Group', 'NTS Group', 'Joh. Mourik & Co. Holding', 'Mercedes-Benz', 'DIT Personeel', 'Verkade', + 'Hametha', 'Vopak', 'IFF', 'Pearle', 'Mainfreight', 'De Jong & Laan', 'DSV', 'P4People', 'Mazars', 'Cargill', + 'Ten Brinke Groep', 'Alewijnse', 'Agio Cigars', 'Peter Appel Transport', 'Syngenta', 'Avery Dennison', + 'Accon AVM', 'Vitol', 'Vermaat Groep', 'BMC', 'Alcatel-Lucent', 'Maxeda DIY', 'Equens', + 'Van Gelder Groep', 'Emerson Electric Nederland', 'Bakkersland', 'Specsavers', 'E.On', 'Landal Greenparks', + 'IMC Trading', 'Barentz Group', 'Epson', 'Raet', 'Van Oord', 'Thomas Cook Nederland', 'SDU uitgevers', + 'Nedschroef', 'Linde Gas', 'Ewals Cargo Care', 'Theodoor Gilissen', 'TMF Group', 'Cornelis Vrolijk', + 'Jan Linders Supermarkten', 'SIF group', 'BT Nederland', 'Kinepolis', 'Pink Elephant', + 'General Motors Nederland', 'Carlson Wagonlit', 'Bruna', 'Docdata', 'Schenk Tanktransport', 'WPG', 'Peak-IT', + 'Martinair', 'Reesink', 'Elopak Nederland', 'Fagron N.V.', 'OVG Groep', 'Ford Nederland', 'Multi Corporation', + 'Simac', 'Primark', 'Tech Data Nederland', 'Vleesgroothandel Zandbergen', 'Raben Group', 'Farm Frites', + 'Libéma', 'Caldic', 'Portaal', 'Syntus', 'Jacobs DE', 'Stena Line', 'The Phone House', 'Interfood Group', + 'Thales', 'Teva Pharmaceuticals', 'RFS Holland', 'Aebi Schmidt Nederland', + 'Rockwell Automation Nederland', 'Engie Services', 'Hendrix Genetics', 'Qbuzz', 'Unica', + '2SistersFoodGroup', 'Ziut', 'Munckhof Groep', 'Spar Holding', 'Samskip', 'Continental Bakeries', 'Sligro', + 'Merck', 'Foot Locker Europe', 'Unit4', 'PepsiCo', 'Sulzer', 'Tebodin', 'Value8', 'Boels', + 'DKG Groep', 'Bruynzeel Keukens', 'Janssen de Jong Groep', 'ProRail', 'Solid Professionals', 'Hermes Partners', + ) + + def large_company(self): + """ + :example: 'Bol.com' + """ + return self.random_element(self.large_companies) + + def company_prefix(self): + """ + :example 'Stichting' + """ + return self.random_element(self.company_prefixes)

diff --git a/tests/providers/test_company.py b/tests/providers/test_company.py index 0334a08719..ed2ea4a74f 100644 --- a/tests/providers/test_company.py +++ b/tests/providers/test_company.py @@ -13,6 +13,7 @@ from faker.providers.company.pl_PL import ( company_vat_checksum, regon_checksum, local_regon_checksum, Provider as PlProvider, ) +from faker.providers.company.nl_NL import Provider as NlProvider class TestFiFI(unittest.TestCase): @@ -140,3 +141,28 @@ def test_company_suffix(self): suffix = self.factory.company_suffix() assert isinstance(suffix, six.string_types) assert suffix in suffixes + + +class TestNlNL(unittest.TestCase): + """ Tests company in the nl_NL locale """ + + def setUp(self): + self.factory = Faker('nl_NL') + + def test_company_prefix(self): + prefixes = NlProvider.company_prefixes + prefix = self.factory.company_prefix() + assert isinstance(prefix, six.string_types) + assert prefix in prefixes + + def test_company_suffix(self): + suffixes = NlProvider.company_suffixes + suffix = self.factory.company_suffix() + assert isinstance(suffix, six.string_types) + assert suffix in suffixes + + def test_large_companies(self): + companies = NlProvider.large_companies + company = self.factory.large_company() + assert isinstance(company, six.string_types) + assert company in companies

[ { "components": [ { "doc": "", "lines": [ 7, 109 ], "name": "Provider", "signature": "class Provider(CompanyProvider):", "type": "class" }, { "doc": ":example: 'Bol.com'", "lines": [ 99, 103...

[ "tests/providers/test_company.py::TestFiFI::test_company_business_id", "tests/providers/test_company.py::TestJaJP::test_company", "tests/providers/test_company.py::TestPtBR::test_pt_BR_cnpj", "tests/providers/test_company.py::TestPtBR::test_pt_BR_company_id", "tests/providers/test_company.py::TestPtBR::test...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added Dutch company names Added some prefixes and suffixes for common Dutch company names. Also added the top 500 companies in the Netherlands based on: https://www.mt.nl/management/reputatie/mt-500-2018-de-lijst/559930 Closes #929 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/company/nl_NL/__init__.py] (definition of Provider:) class Provider(CompanyProvider): (definition of Provider.large_company:) def large_company(self): """:example: 'Bol.com'""" (definition of Provider.company_prefix:) def company_prefix(self): """:example 'Stichting'""" [end of new definitions in faker/providers/company/nl_NL/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Support for companies for the nl_NL locale I'm currently using faker in a project and would love to use Dutch company namers. I already made changes to do this and would like to commit these. Can you make a branch avaiable for me so I can ask for a merge request? ---------- -------------------- </issues>

6edfdbf6ae90b0153309e3bf066aa3b2d16494a7

sympy__sympy-16276

16,276

sympy/sympy

1.4

6979792bd194c385a851a8e44925b522630d04de

2019-03-16T12:26:02Z

diff --git a/doc/src/modules/plotting.rst b/doc/src/modules/plotting.rst index e9971d11f777..03ace2caa231 100644 --- a/doc/src/modules/plotting.rst +++ b/doc/src/modules/plotting.rst @@ -45,6 +45,12 @@ Plotting Function Reference .. autofunction:: sympy.plotting.plot_implicit.plot_implicit +PlotGrid Class +-------------- + +.. autoclass:: sympy.plotting.plot.PlotGrid + :members: + Series Classes -------------- diff --git a/sympy/plotting/__init__.py b/sympy/plotting/__init__.py index e15b35e40cb5..6ddc146c0d95 100644 --- a/sympy/plotting/__init__.py +++ b/sympy/plotting/__init__.py @@ -2,5 +2,6 @@ from .plot_implicit import plot_implicit from .textplot import textplot from .pygletplot import PygletPlot +from .plot import PlotGrid from .plot import (plot, plot_parametric, plot3d, plot3d_parametric_surface, plot3d_parametric_line) diff --git a/sympy/plotting/plot.py b/sympy/plotting/plot.py index 0ebb68b40b74..6d8d6ca4d53b 100644 --- a/sympy/plotting/plot.py +++ b/sympy/plotting/plot.py @@ -289,6 +289,141 @@ def extend(self, arg): raise TypeError('Expecting Plot or sequence of BaseSeries') +class PlotGrid(object): + """This class helps to plot subplots from already created sympy plots + in a single figure. + + Examples + ======== + + .. plot:: + :context: close-figs + :format: doctest + :include-source: True + + >>> from sympy import symbols + >>> from sympy.plotting import plot, plot3d, PlotGrid + >>> x, y = symbols('x, y') + >>> p1 = plot(x, x**2, x**3, (x, -5, 5)) + >>> p2 = plot((x**2, (x, -6, 6)), (x, (x, -5, 5))) + >>> p3 = plot(x**3, (x, -5, 5)) + >>> p4 = plot3d(x*y, (x, -5, 5), (y, -5, 5)) + + Plotting vertically in a single line: + + .. plot:: + :context: close-figs + :format: doctest + :include-source: True + + >>> PlotGrid(2, 1 , p1, p2) + PlotGrid object containing: + Plot[0]:Plot object containing: + [0]: cartesian line: x for x over (-5.0, 5.0) + [1]: cartesian line: x**2 for x over (-5.0, 5.0) + [2]: cartesian line: x**3 for x over (-5.0, 5.0) + Plot[1]:Plot object containing: + [0]: cartesian line: x**2 for x over (-6.0, 6.0) + [1]: cartesian line: x for x over (-5.0, 5.0) + + Plotting horizontally in a single line: + + .. plot:: + :context: close-figs + :format: doctest + :include-source: True + + >>> PlotGrid(1, 3 , p2, p3, p4) + PlotGrid object containing: + Plot[0]:Plot object containing: + [0]: cartesian line: x**2 for x over (-6.0, 6.0) + [1]: cartesian line: x for x over (-5.0, 5.0) + Plot[1]:Plot object containing: + [0]: cartesian line: x**3 for x over (-5.0, 5.0) + Plot[2]:Plot object containing: + [0]: cartesian surface: x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0) + + Plotting in a grid form: + + .. plot:: + :context: close-figs + :format: doctest + :include-source: True + + >>> PlotGrid(2, 2, p1, p2 ,p3, p4) + PlotGrid object containing: + Plot[0]:Plot object containing: + [0]: cartesian line: x for x over (-5.0, 5.0) + [1]: cartesian line: x**2 for x over (-5.0, 5.0) + [2]: cartesian line: x**3 for x over (-5.0, 5.0) + Plot[1]:Plot object containing: + [0]: cartesian line: x**2 for x over (-6.0, 6.0) + [1]: cartesian line: x for x over (-5.0, 5.0) + Plot[2]:Plot object containing: + [0]: cartesian line: x**3 for x over (-5.0, 5.0) + Plot[3]:Plot object containing: + [0]: cartesian surface: x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0) + + """ + def __init__(self, nrows, ncolumns, *args, **kwargs): + """ + Parameters + ========== + + nrows : The number of rows that should be in the grid of the + required subplot + ncolumns : The number of columns that should be in the grid + of the required subplot + + nrows and ncolumns together define the required grid + + Arguments + ========= + + A list of predefined plot objects entered in a row-wise sequence + i.e. plot objects which are to be in the top row of the required + grid are written first, then the second row objects and so on + + Keyword arguments + ================= + + show : Boolean + The default value is set to ``True``. Set show to ``False`` and + the function will not display the subplot. The returned instance + of the ``PlotGrid`` class can then be used to save or display the + plot by calling the ``save()`` and ``show()`` methods + respectively. + """ + self.nrows = nrows + self.ncolumns = ncolumns + self._series = [] + self.args = args + for arg in args: + self._series.append(arg._series) + self.backend = DefaultBackend + show = kwargs.pop('show', True) + if show: + self.show() + + def show(self): + if hasattr(self, '_backend'): + self._backend.close() + self._backend = self.backend(self) + self._backend.show() + + def save(self, path): + if hasattr(self, '_backend'): + self._backend.close() + self._backend = self.backend(self) + self._backend.save(path) + + def __str__(self): + plot_strs = [('Plot[%d]:' % i) + str(plot) + for i, plot in enumerate(self.args)] + + return 'PlotGrid object containing:\n' + '\n'.join(plot_strs) + + ############################################################################## # Data Series ############################################################################## @@ -908,80 +1043,90 @@ def __init__(self, parent): class MatplotlibBackend(BaseBackend): def __init__(self, parent): super(MatplotlibBackend, self).__init__(parent) - are_3D = [s.is_3D for s in self.parent._series] self.matplotlib = import_module('matplotlib', __import__kwargs={'fromlist': ['pyplot', 'cm', 'collections']}, min_module_version='1.1.0', catch=(RuntimeError,)) self.plt = self.matplotlib.pyplot self.cm = self.matplotlib.cm self.LineCollection = self.matplotlib.collections.LineCollection - if any(are_3D) and not all(are_3D): - raise ValueError('The matplotlib backend can not mix 2D and 3D.') - elif not any(are_3D): - self.fig = self.plt.figure() - self.ax = self.fig.add_subplot(111) - self.ax.spines['left'].set_position('zero') - self.ax.spines['right'].set_color('none') - self.ax.spines['bottom'].set_position('zero') - self.ax.spines['top'].set_color('none') - self.ax.spines['left'].set_smart_bounds(True) - self.ax.spines['bottom'].set_smart_bounds(False) - self.ax.xaxis.set_ticks_position('bottom') - self.ax.yaxis.set_ticks_position('left') - elif all(are_3D): - ## mpl_toolkits.mplot3d is necessary for - ## projection='3d' - mpl_toolkits = import_module('mpl_toolkits', - __import__kwargs={'fromlist': ['mplot3d']}) - self.fig = self.plt.figure() - self.ax = self.fig.add_subplot(111, projection='3d') - def process_series(self): - parent = self.parent + if isinstance(self.parent, Plot): + nrows, ncolumns = 1, 1 + series_list = [self.parent._series] + elif isinstance(self.parent, PlotGrid): + nrows, ncolumns = self.parent.nrows, self.parent.ncolumns + series_list = self.parent._series + + self.ax = [] + self.fig = self.plt.figure() - for s in self.parent._series: + for i, series in enumerate(series_list): + are_3D = [s.is_3D for s in series] + + if any(are_3D) and not all(are_3D): + raise ValueError('The matplotlib backend can not mix 2D and 3D.') + elif all(are_3D): + # mpl_toolkits.mplot3d is necessary for + # projection='3d' + mpl_toolkits = import_module('mpl_toolkits', + __import__kwargs={'fromlist': ['mplot3d']}) + self.ax.append(self.fig.add_subplot(nrows, ncolumns, i + 1, projection='3d')) + + elif not any(are_3D): + self.ax.append(self.fig.add_subplot(nrows, ncolumns, i + 1)) + self.ax[i].spines['left'].set_position('zero') + self.ax[i].spines['right'].set_color('none') + self.ax[i].spines['bottom'].set_position('zero') + self.ax[i].spines['top'].set_color('none') + self.ax[i].spines['left'].set_smart_bounds(True) + self.ax[i].spines['bottom'].set_smart_bounds(False) + self.ax[i].xaxis.set_ticks_position('bottom') + self.ax[i].yaxis.set_ticks_position('left') + + def _process_series(self, series, ax, parent): + for s in series: # Create the collections if s.is_2Dline: collection = self.LineCollection(s.get_segments()) - self.ax.add_collection(collection) + ax.add_collection(collection) elif s.is_contour: - self.ax.contour(*s.get_meshes()) + ax.contour(*s.get_meshes()) elif s.is_3Dline: # TODO too complicated, I blame matplotlib mpl_toolkits = import_module('mpl_toolkits', __import__kwargs={'fromlist': ['mplot3d']}) art3d = mpl_toolkits.mplot3d.art3d collection = art3d.Line3DCollection(s.get_segments()) - self.ax.add_collection(collection) + ax.add_collection(collection) x, y, z = s.get_points() - self.ax.set_xlim((min(x), max(x))) - self.ax.set_ylim((min(y), max(y))) - self.ax.set_zlim((min(z), max(z))) + ax.set_xlim((min(x), max(x))) + ax.set_ylim((min(y), max(y))) + ax.set_zlim((min(z), max(z))) elif s.is_3Dsurface: x, y, z = s.get_meshes() - collection = self.ax.plot_surface(x, y, z, + collection = ax.plot_surface(x, y, z, cmap=getattr(self.cm, 'viridis', self.cm.jet), rstride=1, cstride=1, linewidth=0.1) elif s.is_implicit: - #Smart bounds have to be set to False for implicit plots. - self.ax.spines['left'].set_smart_bounds(False) - self.ax.spines['bottom'].set_smart_bounds(False) + # Smart bounds have to be set to False for implicit plots. + ax.spines['left'].set_smart_bounds(False) + ax.spines['bottom'].set_smart_bounds(False) points = s.get_raster() if len(points) == 2: - #interval math plotting + # interval math plotting x, y = _matplotlib_list(points[0]) - self.ax.fill(x, y, facecolor=s.line_color, edgecolor='None') + ax.fill(x, y, facecolor=s.line_color, edgecolor='None') else: # use contourf or contour depending on whether it is # an inequality or equality. - #XXX: ``contour`` plots multiple lines. Should be fixed. + # XXX: ``contour`` plots multiple lines. Should be fixed. ListedColormap = self.matplotlib.colors.ListedColormap colormap = ListedColormap(["white", s.line_color]) xarray, yarray, zarray, plot_type = points if plot_type == 'contour': - self.ax.contour(xarray, yarray, zarray, cmap=colormap) + ax.contour(xarray, yarray, zarray, cmap=colormap) else: - self.ax.contourf(xarray, yarray, zarray, cmap=colormap) + ax.contourf(xarray, yarray, zarray, cmap=colormap) else: raise ValueError('The matplotlib backend supports only ' 'is_2Dline, is_3Dline, is_3Dsurface and ' @@ -1010,14 +1155,13 @@ def process_series(self): # Set global options. # TODO The 3D stuff # XXX The order of those is important. - mpl_toolkits = import_module('mpl_toolkits', __import__kwargs={'fromlist': ['mplot3d']}) Axes3D = mpl_toolkits.mplot3d.Axes3D - if parent.xscale and not isinstance(self.ax, Axes3D): - self.ax.set_xscale(parent.xscale) - if parent.yscale and not isinstance(self.ax, Axes3D): - self.ax.set_yscale(parent.yscale) + if parent.xscale and not isinstance(ax, Axes3D): + ax.set_xscale(parent.xscale) + if parent.yscale and not isinstance(ax, Axes3D): + ax.set_yscale(parent.yscale) if parent.xlim: from sympy.core.basic import Basic xlim = parent.xlim @@ -1028,12 +1172,12 @@ def process_series(self): raise ValueError( "All numbers from xlim={} must be finite".format(xlim)) xlim = (float(i) for i in xlim) - self.ax.set_xlim(xlim) + ax.set_xlim(xlim) else: if all(isinstance(s, LineOver1DRangeSeries) for s in parent._series): starts = [s.start for s in parent._series] ends = [s.end for s in parent._series] - self.ax.set_xlim(min(starts), max(ends)) + ax.set_xlim(min(starts), max(ends)) if parent.ylim: from sympy.core.basic import Basic ylim = parent.ylim @@ -1044,40 +1188,56 @@ def process_series(self): raise ValueError( "All numbers from ylim={} must be finite".format(ylim)) ylim = (float(i) for i in ylim) - self.ax.set_ylim(ylim) - if not isinstance(self.ax, Axes3D) or self.matplotlib.__version__ >= '1.2.0': # XXX in the distant future remove this check - self.ax.set_autoscale_on(parent.autoscale) + ax.set_ylim(ylim) + if not isinstance(ax, Axes3D) or self.matplotlib.__version__ >= '1.2.0': # XXX in the distant future remove this check + ax.set_autoscale_on(parent.autoscale) if parent.axis_center: val = parent.axis_center - if isinstance(self.ax, Axes3D): + if isinstance(ax, Axes3D): pass elif val == 'center': - self.ax.spines['left'].set_position('center') - self.ax.spines['bottom'].set_position('center') + ax.spines['left'].set_position('center') + ax.spines['bottom'].set_position('center') elif val == 'auto': - xl, xh = self.ax.get_xlim() - yl, yh = self.ax.get_ylim() + xl, xh = ax.get_xlim() + yl, yh = ax.get_ylim() pos_left = ('data', 0) if xl*xh <= 0 else 'center' pos_bottom = ('data', 0) if yl*yh <= 0 else 'center' - self.ax.spines['left'].set_position(pos_left) - self.ax.spines['bottom'].set_position(pos_bottom) + ax.spines['left'].set_position(pos_left) + ax.spines['bottom'].set_position(pos_bottom) else: - self.ax.spines['left'].set_position(('data', val[0])) - self.ax.spines['bottom'].set_position(('data', val[1])) + ax.spines['left'].set_position(('data', val[0])) + ax.spines['bottom'].set_position(('data', val[1])) if not parent.axis: - self.ax.set_axis_off() + ax.set_axis_off() if parent.legend: - if self.ax.legend(): - self.ax.legend_.set_visible(parent.legend) + if ax.legend(): + ax.legend_.set_visible(parent.legend) if parent.margin: - self.ax.set_xmargin(parent.margin) - self.ax.set_ymargin(parent.margin) + ax.set_xmargin(parent.margin) + ax.set_ymargin(parent.margin) if parent.title: - self.ax.set_title(parent.title) + ax.set_title(parent.title) if parent.xlabel: - self.ax.set_xlabel(parent.xlabel, position=(1, 0)) + ax.set_xlabel(parent.xlabel, position=(1, 0)) if parent.ylabel: - self.ax.set_ylabel(parent.ylabel, position=(0, 1)) + ax.set_ylabel(parent.ylabel, position=(0, 1)) + + def process_series(self): + """ + Iterates over every ``Plot`` object and further calls + _process_series() + """ + parent = self.parent + if isinstance(parent, Plot): + series_list = [parent._series] + else: + series_list = parent._series + + for i, (series, ax) in enumerate(zip(series_list, self.ax)): + if isinstance(self.parent, PlotGrid): + parent = self.parent.args[i] + self._process_series(series, ax, parent) def show(self): self.process_series() @@ -1085,6 +1245,7 @@ def show(self): # you can uncomment the next line and remove the pyplot.show() call #self.fig.show() if _show: + self.fig.tight_layout() self.plt.show() else: self.close()

diff --git a/sympy/plotting/tests/test_plot.py b/sympy/plotting/tests/test_plot.py index 3052951889b0..a4a1488c11d1 100644 --- a/sympy/plotting/tests/test_plot.py +++ b/sympy/plotting/tests/test_plot.py @@ -2,7 +2,7 @@ oo, LambertW, I, meijerg, exp_polar, Max, Piecewise, And) from sympy.plotting import (plot, plot_parametric, plot3d_parametric_line, plot3d, plot3d_parametric_surface) -from sympy.plotting.plot import unset_show, plot_contour +from sympy.plotting.plot import unset_show, plot_contour, PlotGrid from sympy.utilities import lambdify as lambdify_ from sympy.utilities.pytest import skip, raises, warns from sympy.plotting.experimental_lambdify import lambdify @@ -323,6 +323,37 @@ def plot_and_save_6(name): + meijerg(((1/2,), ()), ((5, 0, 1/2), ()), 5*x**2 * exp_polar(I*pi)/2)) / (48 * pi), (x, 1e-6, 1e-2)).save(tmp_file()) + +def plotgrid_and_save(name): + tmp_file = TmpFileManager.tmp_file + + x = Symbol('x') + y = Symbol('y') + z = Symbol('z') + p1 = plot(x) + p2 = plot_parametric((sin(x), cos(x)), (x, sin(x)), show=False) + p3 = plot_parametric(cos(x), sin(x), adaptive=False, nb_of_points=500, show=False) + p4 = plot3d_parametric_line(sin(x), cos(x), x, show=False) + # symmetric grid + p = PlotGrid(2, 2, p1, p2, p3, p4) + p.save(tmp_file('%s_grid1' % name)) + p._backend.close() + + # grid size greater than the number of subplots + p = PlotGrid(3, 4, p1, p2, p3, p4) + p.save(tmp_file('%s_grid2' % name)) + p._backend.close() + + p5 = plot(cos(x),(x, -pi, pi), show=False) + p5[0].line_color = lambda a: a + p6 = plot(Piecewise((1, x > 0), (0, True)), (x, -1, 1), show=False) + p7 = plot_contour((x**2 + y**2, (x, -5, 5), (y, -5, 5)), (x**3 + y**3, (x, -3, 3), (y, -3, 3)), show=False) + # unsymmetric grid (subplots in one line) + p = PlotGrid(1, 3, p5, p6, p7) + p.save(tmp_file('%s_grid3' % name)) + p._backend.close() + + def test_matplotlib_1(): matplotlib = import_module('matplotlib', min_module_version='1.1.0', catch=(RuntimeError,)) @@ -395,6 +426,20 @@ def test_matplotlib_6(): else: skip("Matplotlib not the default backend") + +def test_matplotlib_7(): + + matplotlib = import_module('matplotlib', min_module_version='1.1.0', catch=(RuntimeError,)) + if matplotlib: + try: + plotgrid_and_save('test') + finally: + # clean up + TmpFileManager.cleanup() + else: + skip("Matplotlib not the default backend") + + # Tests for exception handling in experimental_lambdify def test_experimental_lambify(): x = Symbol('x')

diff --git a/doc/src/modules/plotting.rst b/doc/src/modules/plotting.rst index e9971d11f777..03ace2caa231 100644 --- a/doc/src/modules/plotting.rst +++ b/doc/src/modules/plotting.rst @@ -45,6 +45,12 @@ Plotting Function Reference .. autofunction:: sympy.plotting.plot_implicit.plot_implicit +PlotGrid Class +-------------- + +.. autoclass:: sympy.plotting.plot.PlotGrid + :members: + Series Classes --------------

[ { "components": [ { "doc": "This class helps to plot subplots from already created sympy plots\nin a single figure.\n\nExamples\n========\n\n.. plot::\n :context: close-figs\n :format: doctest\n :include-source: True\n\n >>> from sympy import symbols\n >>> from sympy.plotting import pl...

[ "test_experimental_lambify" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> added functionality to obtain subplots from already created plots. This PR gives a solution to the problem as discussed in Issue #15328 A class `PlotGrid` have been introduced in `plot.py` of plotting module. This class takes some already created `Plot` objects and makes a subplot figure using`matplotlib` backend. TODO's: - [x] Improve documentation - [x] Add tests #### Release Notes  - plotting - plotting module can now create subplots i.e can plot more than one plot in a single figure using `PlotGrid`  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/plotting/plot.py] (definition of PlotGrid:) class PlotGrid(object): """This class helps to plot subplots from already created sympy plots in a single figure. Examples ======== .. plot:: :context: close-figs :format: doctest :include-source: True >>> from sympy import symbols >>> from sympy.plotting import plot, plot3d, PlotGrid >>> x, y = symbols('x, y') >>> p1 = plot(x, x**2, x**3, (x, -5, 5)) >>> p2 = plot((x**2, (x, -6, 6)), (x, (x, -5, 5))) >>> p3 = plot(x**3, (x, -5, 5)) >>> p4 = plot3d(x*y, (x, -5, 5), (y, -5, 5)) Plotting vertically in a single line: .. plot:: :context: close-figs :format: doctest :include-source: True >>> PlotGrid(2, 1 , p1, p2) PlotGrid object containing: Plot[0]:Plot object containing: [0]: cartesian line: x for x over (-5.0, 5.0) [1]: cartesian line: x**2 for x over (-5.0, 5.0) [2]: cartesian line: x**3 for x over (-5.0, 5.0) Plot[1]:Plot object containing: [0]: cartesian line: x**2 for x over (-6.0, 6.0) [1]: cartesian line: x for x over (-5.0, 5.0) Plotting horizontally in a single line: .. plot:: :context: close-figs :format: doctest :include-source: True >>> PlotGrid(1, 3 , p2, p3, p4) PlotGrid object containing: Plot[0]:Plot object containing: [0]: cartesian line: x**2 for x over (-6.0, 6.0) [1]: cartesian line: x for x over (-5.0, 5.0) Plot[1]:Plot object containing: [0]: cartesian line: x**3 for x over (-5.0, 5.0) Plot[2]:Plot object containing: [0]: cartesian surface: x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0) Plotting in a grid form: .. plot:: :context: close-figs :format: doctest :include-source: True >>> PlotGrid(2, 2, p1, p2 ,p3, p4) PlotGrid object containing: Plot[0]:Plot object containing: [0]: cartesian line: x for x over (-5.0, 5.0) [1]: cartesian line: x**2 for x over (-5.0, 5.0) [2]: cartesian line: x**3 for x over (-5.0, 5.0) Plot[1]:Plot object containing: [0]: cartesian line: x**2 for x over (-6.0, 6.0) [1]: cartesian line: x for x over (-5.0, 5.0) Plot[2]:Plot object containing: [0]: cartesian line: x**3 for x over (-5.0, 5.0) Plot[3]:Plot object containing: [0]: cartesian surface: x*y for x over (-5.0, 5.0) and y over (-5.0, 5.0)""" (definition of PlotGrid.__init__:) def __init__(self, nrows, ncolumns, *args, **kwargs): """Parameters ========== nrows : The number of rows that should be in the grid of the required subplot ncolumns : The number of columns that should be in the grid of the required subplot nrows and ncolumns together define the required grid Arguments ========= A list of predefined plot objects entered in a row-wise sequence i.e. plot objects which are to be in the top row of the required grid are written first, then the second row objects and so on Keyword arguments ================= show : Boolean The default value is set to ``True``. Set show to ``False`` and the function will not display the subplot. The returned instance of the ``PlotGrid`` class can then be used to save or display the plot by calling the ``save()`` and ``show()`` methods respectively.""" (definition of PlotGrid.show:) def show(self): (definition of PlotGrid.save:) def save(self, path): (definition of PlotGrid.__str__:) def __str__(self): (definition of MatplotlibBackend._process_series:) def _process_series(self, series, ax, parent): [end of new definitions in sympy/plotting/plot.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

e941ad69638189ea42507331e417b88837357dec

sympy__sympy-16253

16,253

sympy/sympy

1.4

93a65b9bb8a615906e73d5885ff03076bcabc555

2019-03-14T05:24:14Z

diff --git a/sympy/utilities/misc.py b/sympy/utilities/misc.py index 89b3ec95adf9..af19d67f3bdf 100644 --- a/sympy/utilities/misc.py +++ b/sympy/utilities/misc.py @@ -7,7 +7,8 @@ import re as _re import struct from textwrap import fill, dedent -from sympy.core.compatibility import get_function_name, range, as_int +from sympy.core.compatibility import (get_function_name, range, as_int, + string_types) @@ -24,13 +25,71 @@ def filldedent(s, w=70): Empty line stripping serves to deal with docstrings like this one that start with a newline after the initial triple quote, inserting an empty - line at the beginning of the string.""" + line at the beginning of the string. + + See Also + ======== + strlines, rawlines + """ return '\n' + fill(dedent(str(s)).strip('\n'), width=w) +def strlines(s, c=64, short=False): + """Return a cut-and-pastable string that, when printed, is + equivalent to the input. The lines will be surrounded by + parentheses and no line will be longer than c (default 64) + characters. If the line contains newlines characters, the + `rawlines` result will be returned. If ``short`` is True + (default is False) then if there is one line it will be + returned without bounding parentheses. + + Examples + ======== + + >>> from sympy.utilities.misc import strlines + >>> q = 'this is a long string that should be broken into shorter lines' + >>> print(strlines(q, 40)) + ( + 'this is a long string that should be b' + 'roken into shorter lines' + ) + >>> q == ( + ... 'this is a long string that should be b' + ... 'roken into shorter lines' + ... ) + True + + See Also + ======== + filldedent, rawlines + """ + if type(s) not in string_types: + raise ValueError('expecting string input') + if '\n' in s: + return rawlines(s) + q = '"' if repr(s).startswith('"') else "'" + q = (q,)*2 + if '\\' in s: # use r-string + m = '(\nr%s%%s%s\n)' % q + j = '%s\nr%s' % q + c -= 3 + else: + m = '(\n%s%%s%s\n)' % q + j = '%s\n%s' % q + c -= 2 + out = [] + while s: + out.append(s[:c]) + s=s[c:] + if short and len(out) == 1: + return (m % out[0]).splitlines()[1] # strip bounding (\n...\n) + return m % j.join(out) + + def rawlines(s): """Return a cut-and-pastable string that, when printed, is equivalent - to the input. The string returned is formatted so it can be indented + to the input. Use this when there is more than one line in the + string. The string returned is formatted so it can be indented nicely within tests; in some cases it is wrapped in the dedent function which has to be imported from textwrap. @@ -82,22 +141,26 @@ def rawlines(s): 'that\\n' ' ' ) + + See Also + ======== + filldedent, strlines """ lines = s.split('\n') if len(lines) == 1: return repr(lines[0]) triple = ["'''" in s, '"""' in s] if any(li.endswith(' ') for li in lines) or '\\' in s or all(triple): - rv = ["("] + rv = [] # add on the newlines trailing = s.endswith('\n') last = len(lines) - 1 for i, li in enumerate(lines): if i != last or trailing: - rv.append(repr(li)[:-1] + '\\n\'') + rv.append(repr(li + '\n')) else: rv.append(repr(li)) - return '\n '.join(rv) + '\n)' + return '(\n %s\n)' % '\n '.join(rv) else: rv = '\n '.join(lines) if triple[0]:

diff --git a/sympy/utilities/tests/test_misc.py b/sympy/utilities/tests/test_misc.py index 63d2203820ab..3eae4cdeb0a2 100644 --- a/sympy/utilities/tests/test_misc.py +++ b/sympy/utilities/tests/test_misc.py @@ -1,5 +1,6 @@ +from textwrap import dedent from sympy.core.compatibility import range, unichr -from sympy.utilities.misc import translate, replace, ordinal, rawlines +from sympy.utilities.misc import translate, replace, ordinal, rawlines, strlines def test_translate(): abc = 'abc' @@ -41,3 +42,45 @@ def test_ordinal(): def test_rawlines(): assert rawlines('a a\na') == "dedent('''\\\n a a\n a''')" assert rawlines('a a') == "'a a'" + assert rawlines(strlines('\\le"ft')) == ( + '(\n' + " '(\\n'\n" + ' \'r\\\'\\\\le"ft\\\'\\n\'\n' + " ')'\n" + ')') + + +def test_strlines(): + q = 'this quote (") is in the middle' + # the following assert rhs was prepared with + # print(rawlines(strlines(q, 10))) + assert strlines(q, 10) == dedent('''\ + ( + 'this quo' + 'te (") i' + 's in the' + ' middle' + )''') + assert q == ( + 'this quo' + 'te (") i' + 's in the' + ' middle' + ) + q = "this quote (') is in the middle" + assert strlines(q, 20) == dedent('''\ + ( + "this quote (') is " + "in the middle" + )''') + assert strlines('\\left') == ( + '(\n' + "r'\\left'\n" + ')') + assert strlines('\\left', short=True) == r"r'\left'" + assert strlines('\\le"ft') == ( + '(\n' + 'r\'\\le"ft\'\n' + ')') + q = 'this\nother line' + assert strlines(q) == rawlines(q)

[ { "components": [ { "doc": "Return a cut-and-pastable string that, when printed, is\nequivalent to the input. The lines will be surrounded by\nparentheses and no line will be longer than c (default 64)\ncharacters. If the line contains newlines characters, the\n`rawlines` result will be returned....

[ "test_translate", "test_replace", "test_ordinal", "test_rawlines" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> misc: add strlines When wanting to test the output that is a long string and needing to keep lines under 72 characters, it is a bit tedious to split the line and add the quotes. `strlines` can help in the process. It will use rawlines if necessary, too. ``` Given: func(s) -> longstring print(strlines(func(s))) <copy what was printed> Now you can test func(s) == <paste> ``` Here is an example of it wrapping a string to a width of 30 ```python >>> q = 'this is a long string that just needs to be shorter' >>> print(strlines(q, 30)) ( 'this is a long string that j' 'ust needs to be shorter' ) >>> q == ( ... 'this is a long string that j' ... 'ust needs to be shorter' ... ) True ``` A quoting issue was fixed for rawlines, too. Instead of adding a quote character, the repr form is used.  #### References to other Issues or PRs  #### Brief description of what is fixed or changed #### Other comments `strlines` will automatically call rawlines if there is more than one logical line in the input #### Release Notes   - utilities - `strlines` added: prints a string into shorter lines in a format that can be copied and used in an equality test  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/utilities/misc.py] (definition of strlines:) def strlines(s, c=64, short=False): """Return a cut-and-pastable string that, when printed, is equivalent to the input. The lines will be surrounded by parentheses and no line will be longer than c (default 64) characters. If the line contains newlines characters, the `rawlines` result will be returned. If ``short`` is True (default is False) then if there is one line it will be returned without bounding parentheses. Examples ======== >>> from sympy.utilities.misc import strlines >>> q = 'this is a long string that should be broken into shorter lines' >>> print(strlines(q, 40)) ( 'this is a long string that should be b' 'roken into shorter lines' ) >>> q == ( ... 'this is a long string that should be b' ... 'roken into shorter lines' ... ) True See Also ======== filldedent, rawlines""" [end of new definitions in sympy/utilities/misc.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

e941ad69638189ea42507331e417b88837357dec

sympy__sympy-16248

16,248

sympy/sympy

1.4

35b7b87c03f8cbbd7d185e55af8170702eb861af

2019-03-13T16:47:06Z

diff --git a/sympy/combinatorics/perm_groups.py b/sympy/combinatorics/perm_groups.py index b9aebfb6f47b..38f2a3130ecd 100644 --- a/sympy/combinatorics/perm_groups.py +++ b/sympy/combinatorics/perm_groups.py @@ -1678,6 +1678,31 @@ def is_abelian(self): return False return True + def is_elementary(self, p): + """Return ``True`` if the group is elementary abelian. An elementary + abelian group is a finite abelian group, where every nontrivial + element has order `p`, where `p` is a prime. + + Examples + ======== + + >>> from sympy.combinatorics import Permutation + >>> from sympy.combinatorics.perm_groups import PermutationGroup + >>> a = Permutation([0, 2, 1]) + >>> G = PermutationGroup([a]) + >>> G.is_elementary(2) + True + >>> a = Permutation([0, 2, 1, 3]) + >>> b = Permutation([3, 1, 2, 0]) + >>> G = PermutationGroup([a, b]) + >>> G.is_elementary(2) + True + >>> G.is_elementary(3) + False + + """ + return self.is_abelian and all(g.order() == p for g in self.generators) + def is_alt_sym(self, eps=0.05, _random_prec=None): r"""Monte Carlo test for the symmetric/alternating group for degrees >= 8. @@ -2073,6 +2098,25 @@ def is_subgroup(self, G, strict=True): return False return all(G.contains(g, strict=strict) for g in gens) + @property + def is_polycyclic(self): + """Return ``True`` if a group is polycyclic. A group is polycyclic if + it has a subnormal series with cyclic factors. For finite groups, + this is the same as if the group is solvable. + + Examples + ======== + + >>> from sympy.combinatorics import Permutation, PermutationGroup + >>> a = Permutation([0, 2, 1, 3]) + >>> b = Permutation([2, 0, 1, 3]) + >>> G = PermutationGroup([a, b]) + >>> G.is_polycyclic + True + + """ + return self.is_solvable + def is_transitive(self, strict=True): """Test if the group is transitive.

diff --git a/sympy/combinatorics/tests/test_perm_groups.py b/sympy/combinatorics/tests/test_perm_groups.py index 64dd4d299d11..0c03f4a5741c 100644 --- a/sympy/combinatorics/tests/test_perm_groups.py +++ b/sympy/combinatorics/tests/test_perm_groups.py @@ -888,3 +888,34 @@ def _strong_test(P): c = Permutation(4,5) P = PermutationGroup(c, a, b) assert _strong_test(P) + + +def test_polycyclic(): + a = Permutation([0, 1, 2]) + b = Permutation([2, 1, 0]) + G = PermutationGroup([a, b]) + assert G.is_polycyclic == True + + a = Permutation([1, 2, 3, 4, 0]) + b = Permutation([1, 0, 2, 3, 4]) + G = PermutationGroup([a, b]) + assert G.is_polycyclic == False + + +def test_elementary(): + a = Permutation([1, 5, 2, 0, 3, 6, 4]) + G = PermutationGroup([a]) + assert G.is_elementary(7) == False + + a = Permutation(0, 1)(2, 3) + b = Permutation(0, 2)(3, 1) + G = PermutationGroup([a, b]) + assert G.is_elementary(2) == True + c = Permutation(4, 5, 6) + G = PermutationGroup([a, b, c]) + assert G.is_elementary(2) == False + + G = SymmetricGroup(4).sylow_subgroup(2) + assert G.is_elementary(2) == False + H = AlternatingGroup(4).sylow_subgroup(2) + assert H.is_elementary(2) == True

[ { "components": [ { "doc": "Return ``True`` if the group is elementary abelian. An elementary\nabelian group is a finite abelian group, where every nontrivial\nelement has order `p`, where `p` is a prime.\n\nExamples\n========\n\n>>> from sympy.combinatorics import Permutation\n>>> from sympy.comb...

[ "test_polycyclic" ]

[ "test_has", "test_generate", "test_order", "test_equality", "test_stabilizer", "test_center", "test_centralizer", "test_coset_rank", "test_coset_factor", "test_orbits", "test_is_normal", "test_eq", "test_derived_subgroup", "test_is_solvable", "test_rubik1", "test_direct_product", "te...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add Elementary and Polycyclic groups in Permutation groups   #### Brief description of what is fixed or changed `Elementary` and `Polycyclic` groups has been implemented where `Elementary Group` is defined as a finite `abelian group`, where every `nontrivial` element has an order of `p`, where `p` is a `prime` and `Polycyclic Group` for a finite group is same as `solvable group`. One TODO task may be implementing polycyclic_group for infiite groups. #### Other comments #### Release Notes   * combinatorics * elementary and polycyclic groups has been added to perm_groups.py  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/combinatorics/perm_groups.py] (definition of PermutationGroup.is_elementary:) def is_elementary(self, p): """Return ``True`` if the group is elementary abelian. An elementary abelian group is a finite abelian group, where every nontrivial element has order `p`, where `p` is a prime. Examples ======== >>> from sympy.combinatorics import Permutation >>> from sympy.combinatorics.perm_groups import PermutationGroup >>> a = Permutation([0, 2, 1]) >>> G = PermutationGroup([a]) >>> G.is_elementary(2) True >>> a = Permutation([0, 2, 1, 3]) >>> b = Permutation([3, 1, 2, 0]) >>> G = PermutationGroup([a, b]) >>> G.is_elementary(2) True >>> G.is_elementary(3) False""" (definition of PermutationGroup.is_polycyclic:) def is_polycyclic(self): """Return ``True`` if a group is polycyclic. A group is polycyclic if it has a subnormal series with cyclic factors. For finite groups, this is the same as if the group is solvable. Examples ======== >>> from sympy.combinatorics import Permutation, PermutationGroup >>> a = Permutation([0, 2, 1, 3]) >>> b = Permutation([2, 0, 1, 3]) >>> G = PermutationGroup([a, b]) >>> G.is_polycyclic True""" [end of new definitions in sympy/combinatorics/perm_groups.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

e941ad69638189ea42507331e417b88837357dec

scikit-learn__scikit-learn-13439

13,439

scikit-learn/scikit-learn

0.21

a62775e99f2a5ea3d51db7160fad783f6cd8a4c5

2019-03-12T20:32:50Z

diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 8787b07d5347e..cd4daebf9632b 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -413,6 +413,10 @@ Support for Python 3.4 and below has been officially dropped. - |API| :class:`pipeline.Pipeline` now supports using ``'passthrough'`` as a transformer. :issue:`11144` by :user:`Thomas Fan <thomasjpfan>`. +- |Enhancement| :class:`pipeline.Pipeline` implements ``__len__`` and + therefore ``len(pipeline)`` returns the number of steps in the pipeline. + :issue:`13439` by :user:`Lakshya KD <LakshKD>`. + :mod:`sklearn.preprocessing` ............................ diff --git a/sklearn/pipeline.py b/sklearn/pipeline.py index 7eaf9a46f09e9..d1d03656d2a62 100644 --- a/sklearn/pipeline.py +++ b/sklearn/pipeline.py @@ -199,6 +199,12 @@ def _iter(self, with_final=True): if trans is not None and trans != 'passthrough': yield idx, name, trans + def __len__(self): + """ + Returns the length of the Pipeline + """ + return len(self.steps) + def __getitem__(self, ind): """Returns a sub-pipeline or a single esimtator in the pipeline

diff --git a/sklearn/tests/test_pipeline.py b/sklearn/tests/test_pipeline.py index 8d6fe8f70374e..ed81db747e20c 100644 --- a/sklearn/tests/test_pipeline.py +++ b/sklearn/tests/test_pipeline.py @@ -1069,5 +1069,6 @@ def test_make_pipeline_memory(): assert pipeline.memory is memory pipeline = make_pipeline(DummyTransf(), SVC()) assert pipeline.memory is None + assert len(pipeline) == 2 shutil.rmtree(cachedir)

diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 8787b07d5347e..cd4daebf9632b 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -413,6 +413,10 @@ Support for Python 3.4 and below has been officially dropped. - |API| :class:`pipeline.Pipeline` now supports using ``'passthrough'`` as a transformer. :issue:`11144` by :user:`Thomas Fan <thomasjpfan>`. +- |Enhancement| :class:`pipeline.Pipeline` implements ``__len__`` and + therefore ``len(pipeline)`` returns the number of steps in the pipeline. + :issue:`13439` by :user:`Lakshya KD <LakshKD>`. + :mod:`sklearn.preprocessing` ............................

[ { "components": [ { "doc": "Returns the length of the Pipeline", "lines": [ 202, 206 ], "name": "Pipeline.__len__", "signature": "def __len__(self):", "type": "function" } ], "file": "sklearn/pipeline.py" } ]

[ "sklearn/tests/test_pipeline.py::test_make_pipeline_memory" ]

[ "sklearn/tests/test_pipeline.py::test_pipeline_init", "sklearn/tests/test_pipeline.py::test_pipeline_init_tuple", "sklearn/tests/test_pipeline.py::test_pipeline_methods_anova", "sklearn/tests/test_pipeline.py::test_pipeline_fit_params", "sklearn/tests/test_pipeline.py::test_pipeline_sample_weight_supported"...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> adding length function to pipeline.py  #### Reference Issues/PRs  Fixes #13418 #### What does this implement/fix? Explain your changes. Adding length function in pipeline.py file that will return the length of the pipeline. #### Any other comments?  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/pipeline.py] (definition of Pipeline.__len__:) def __len__(self): """Returns the length of the Pipeline""" [end of new definitions in sklearn/pipeline.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Pipeline should implement __len__ #### Description With the new indexing support `pipe[:len(pipe)]` raises an error. #### Steps/Code to Reproduce ```python from sklearn import svm from sklearn.datasets import samples_generator from sklearn.feature_selection import SelectKBest from sklearn.feature_selection import f_regression from sklearn.pipeline import Pipeline # generate some data to play with X, y = samples_generator.make_classification( n_informative=5, n_redundant=0, random_state=42) anova_filter = SelectKBest(f_regression, k=5) clf = svm.SVC(kernel='linear') pipe = Pipeline([('anova', anova_filter), ('svc', clf)]) len(pipe) ``` #### Versions ``` System: python: 3.6.7 | packaged by conda-forge | (default, Feb 19 2019, 18:37:23) [GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)] executable: /Users/krisz/.conda/envs/arrow36/bin/python machine: Darwin-18.2.0-x86_64-i386-64bit BLAS: macros: HAVE_CBLAS=None lib_dirs: /Users/krisz/.conda/envs/arrow36/lib cblas_libs: openblas, openblas Python deps: pip: 19.0.3 setuptools: 40.8.0 sklearn: 0.21.dev0 numpy: 1.16.2 scipy: 1.2.1 Cython: 0.29.6 pandas: 0.24.1 ``` ---------- None should work just as well, but perhaps you're right that len should be implemented. I don't think we should implement other things from sequences such as iter, however. I think len would be good to have but I would also try to add as little as possible. +1 > I am looking at it. -------------------- </issues>

66cc1c7342f7f0cc0dc57fb6d56053fc46c8e5f0

sympy__sympy-16225

16,225

sympy/sympy

1.4

faad12d1307099aff62b559a84df40a999b8219c

2019-03-10T20:52:32Z

diff --git a/sympy/utilities/iterables.py b/sympy/utilities/iterables.py index de844583b5a9..64fa22caee65 100644 --- a/sympy/utilities/iterables.py +++ b/sympy/utilities/iterables.py @@ -1,6 +1,6 @@ from __future__ import print_function, division -from collections import defaultdict +from collections import defaultdict, OrderedDict from itertools import ( combinations, combinations_with_replacement, permutations, product, product as cartes @@ -929,6 +929,200 @@ def topological_sort(graph, key=None): return L +def strongly_connected_components(G): + r""" + Strongly connected components of a directed graph in reverse topological + order. + + + Parameters + ========== + + graph : tuple[list, list[tuple[T, T]] + A tuple consisting of a list of vertices and a list of edges of + a graph whose strongly connected components are to be found. + + + Examples + ======== + + Consider a directed graph (in dot notation):: + + digraph { + A -> B + A -> C + B -> C + C -> B + B -> D + } + + where vertices are the letters A, B, C and D. This graph can be encoded + using Python's elementary data structures as follows:: + + >>> V = ['A', 'B', 'C', 'D'] + >>> E = [('A', 'B'), ('A', 'C'), ('B', 'C'), ('C', 'B'), ('B', 'D')] + + The strongly connected components of this graph can be computed as + + >>> from sympy.utilities.iterables import strongly_connected_components + + >>> strongly_connected_components((V, E)) + [['D'], ['B', 'C'], ['A']] + + This also gives the components in reverse topological order. + + Since the subgraph containing B and C has a cycle they must be together in + a strongly connected component. A and D are connected to the rest of the + graph but not in a cyclic manner so they appear as their own strongly + connected components. + + + Notes + ===== + + The vertices of the graph must be hashable for the data structures used. + If the vertices are unhashable replace them with integer indices. + + This function uses Tarjan's algorithm to compute the strongly connected + components in `O(|V|+|E|)` (linear) time. + + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Strongly_connected_component + .. [2] https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm + + + See Also + ======== + + utilities.iterables.connected_components() + + """ + # Map from a vertex to its neighbours + V, E = G + Gmap = {vi: [] for vi in V} + for v1, v2 in E: + Gmap[v1].append(v2) + + # Non-recursive Tarjan's algorithm: + lowlink = {} + indices = {} + stack = OrderedDict() + callstack = [] + components = [] + nomore = object() + + def start(v): + index = len(stack) + indices[v] = lowlink[v] = index + stack[v] = None + callstack.append((v, iter(Gmap[v]))) + + def finish(v1): + # Finished a component? + if lowlink[v1] == indices[v1]: + component = [stack.popitem()[0]] + while component[-1] is not v1: + component.append(stack.popitem()[0]) + components.append(component[::-1]) + v2, _ = callstack.pop() + if callstack: + v1, _ = callstack[-1] + lowlink[v1] = min(lowlink[v1], lowlink[v2]) + + for v in V: + if v in indices: + continue + start(v) + while callstack: + v1, it1 = callstack[-1] + v2 = next(it1, nomore) + # Finished children of v1? + if v2 is nomore: + finish(v1) + # Recurse on v2 + elif v2 not in indices: + start(v2) + elif v2 in stack: + lowlink[v1] = min(lowlink[v1], indices[v2]) + + # Reverse topological sort order: + return components + + +def connected_components(G): + r""" + Connected components of an undirected graph or weakly connected components + of a directed graph. + + + Parameters + ========== + + graph : tuple[list, list[tuple[T, T]] + A tuple consisting of a list of vertices and a list of edges of + a graph whose connected components are to be found. + + + Examples + ======== + + + Given an undirected graph:: + + graph { + A -- B + C -- D + } + + We can find the connected components using this function if we include + each edge in both directions:: + + >>> from sympy.utilities.iterables import connected_components + + >>> V = ['A', 'B', 'C', 'D'] + >>> E = [('A', 'B'), ('B', 'A'), ('C', 'D'), ('D', 'C')] + >>> connected_components((V, E)) + [['A', 'B'], ['C', 'D']] + + The weakly connected components of a directed graph can found the same + way. + + + Notes + ===== + + The vertices of the graph must be hashable for the data structures used. + If the vertices are unhashable replace them with integer indices. + + This function uses Tarjan's algorithm to compute the connected components + in `O(|V|+|E|)` (linear) time. + + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Connected_component_(graph_theory) + .. [2] https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm + + + See Also + ======== + + utilities.iterables.strongly_connected_components() + + """ + # Duplicate edges both ways so that the graph is effectively undirected + # and return the strongly connected components: + V, E = G + E_undirected = [] + for v1, v2 in E: + E_undirected.extend([(v1, v2), (v2, v1)]) + return strongly_connected_components((V, E_undirected)) + + def rotate_left(x, y): """ Left rotates a list x by the number of steps specified

diff --git a/sympy/utilities/tests/test_iterables.py b/sympy/utilities/tests/test_iterables.py index a44fa6f51494..17fa2097d3ef 100644 --- a/sympy/utilities/tests/test_iterables.py +++ b/sympy/utilities/tests/test_iterables.py @@ -8,14 +8,15 @@ from sympy.core.compatibility import range from sympy.utilities.iterables import ( _partition, _set_partitions, binary_partitions, bracelets, capture, - cartes, common_prefix, common_suffix, dict_merge, filter_symbols, - flatten, generate_bell, generate_derangements, generate_involutions, - generate_oriented_forest, group, has_dups, ibin, kbins, minlex, multiset, - multiset_combinations, multiset_partitions, + cartes, common_prefix, common_suffix, connected_components, dict_merge, + filter_symbols, flatten, generate_bell, generate_derangements, + generate_involutions, generate_oriented_forest, group, has_dups, ibin, + kbins, minlex, multiset, multiset_combinations, multiset_partitions, multiset_permutations, necklaces, numbered_symbols, ordered, partitions, permutations, postfixes, postorder_traversal, prefixes, reshape, - rotate_left, rotate_right, runs, sift, subsets, take, topological_sort, - unflatten, uniq, variations, ordered_partitions, rotations) + rotate_left, rotate_right, runs, sift, strongly_connected_components, + subsets, take, topological_sort, unflatten, uniq, variations, + ordered_partitions, rotations) from sympy.utilities.enumerative import ( factoring_visitor, multiset_partitions_taocp ) @@ -241,6 +242,40 @@ def test_topological_sort(): raises(ValueError, lambda: topological_sort((V, E + [(10, 7)]))) +def test_strongly_connected_components(): + assert strongly_connected_components(([], [])) == [] + assert strongly_connected_components(([1, 2, 3], [])) == [[1], [2], [3]] + + V = [1, 2, 3] + E = [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1)] + assert strongly_connected_components((V, E)) == [[1, 2, 3]] + + V = [1, 2, 3, 4] + E = [(1, 2), (2, 3), (3, 2), (3, 4)] + assert strongly_connected_components((V, E)) == [[4], [2, 3], [1]] + + V = [1, 2, 3, 4] + E = [(1, 2), (2, 1), (3, 4), (4, 3)] + assert strongly_connected_components((V, E)) == [[1, 2], [3, 4]] + + +def test_connected_components(): + assert connected_components(([], [])) == [] + assert connected_components(([1, 2, 3], [])) == [[1], [2], [3]] + + V = [1, 2, 3] + E = [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1)] + assert connected_components((V, E)) == [[1, 2, 3]] + + V = [1, 2, 3, 4] + E = [(1, 2), (2, 3), (3, 2), (3, 4)] + assert connected_components((V, E)) == [[1, 2, 3, 4]] + + V = [1, 2, 3, 4] + E = [(1, 2), (3, 4)] + assert connected_components((V, E)) == [[1, 2], [3, 4]] + + def test_rotate(): A = [0, 1, 2, 3, 4]

[ { "components": [ { "doc": "Strongly connected components of a directed graph in reverse topological\norder.\n\n\nParameters\n==========\n\ngraph : tuple[list, list[tuple[T, T]]\n A tuple consisting of a list of vertices and a list of edges of\n a graph whose strongly connected components ar...

[ "test_postorder_traversal", "test_flatten", "test_group", "test_subsets", "test_variations", "test_cartes", "test_filter_symbols", "test_numbered_symbols", "test_sift", "test_take", "test_dict_merge", "test_prefixes", "test_postfixes", "test_topological_sort", "test_strongly_connected_co...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add connected_components function in iterables  #### References to other Issues or PRs  Fixes #16174 #### Brief description of what is fixed or changed Adds a new function `connected_components` in sympy.utilities.iterables. The function can be used to find the connected components of a graph and is intended for internal use. #### Other comments As added here the function isn't used yet but I have other ideas for improvements in SymPy that would benefit from this function (as described in #16174 and #16207). #### Release Notes   NO ENTRY  ---------- FWIW: ```python def interpret_digraph(digraph): """ >>> v = var('a:f') >>> digraph = (a>b, a>c, Ne(b, c), b>d, c>f, f>b, b>e) >>> interpret_digraph(digraph) ({0: a, 1: b, 2: c, 3: d, 4: e, 5: f}, (0, 1, 2, 3, 4, 5), ((0, 1), (0, 2), (1, 2), (2, 1), (1, 3), (2, 5), (5, 1), (1, 4))) """ vertices = Tuple(*list(ordered(Tuple(*digraph).free_symbols))) edges = [] for line in digraph: if isinstance(line, Ne): edges.append(line.args) edges.append(line.reversed.args) elif isinstance(line, Gt): edges.append(line.args) elif isinstance(line, Lt): edges.append(line.reversed.args) m, unm = recast_to_ints(vertices) return unm, vertices.subs(m), Tuple(*edges).subs(m) def recast_to_ints(items): """ >>> recast_to_ints((1,3,4,2)) ({1: 0, 2: 3, 3: 1, 4: 2}, {0: 1, 1: 3, 2: 4, 3: 2}) >>> recast_to_ints((x,z,y)) ({x: 0, y: 2, z: 1}, {0: x, 1: z, 2: y}) """ u = list(uniq(items)) try: p= dict(zip(u, range(len(u)))) un = dict([(v, k) for k, v in p.items()]) return mapping except TypeError: p = [(i, items.index(i)) for i in range(len(u))] un = [(v, k) for k, v in p] return p, un ``` BTW, is this a prequel to better logic simplification? Also, if you ever need to work with repetitions, I have an #11196. Where did `interpret_digaph` come from? I wasn't aiming for logic simplification with this but I think @oscargus also had a suggestion involving this. My use case for this was evaluating summations (for cases where the limits depends on the other summation indexes), but logic simplification is always interesting. > Where did `interpret_digaph` come from? I just wrote it to use SymPy expressions to represent a digraph so `x>y` is for `x->y` and `Ne(x, y)` which could be entered in Python as `x<>y` was for the two-way connection. But I guess `Eq(x, y)` would be better since it prints without heads and `!=` or normal math variant is not indicative of a two-way connection. Should the name be `strongly_connected_components`? Or maybe there could be a keyword `strong`. In some cases, it could be desirable to find the actual (connected) components. It was originally called strongly_connected_components and then I changed it because you can use it to find weakly connected components and connected components as well: just include the edges both ways. If the function added here was called `strongly_connected_components` then ```python def strongly_connected_components(G): # The function added here. ... def weakly_connected_components(G): V, E = G E_undirected = [] for v1, v2 in E: E_undirected.extend((v1, v2), (v2, v1)) return strongly_connected_components((V, E_undirected)) def connected_components(G): return weakly_connected_components(G) ``` I could add those three function with these names. I wouldn't normally want to use the other functions though since most likely in any place you would use it duplicating the edges inside the `connected_components` function would also be duplicating the work done at the call site. On other hand a `connected_components` function with an independent implementation could probably have lower overhead than the one added here. I could do that instead if it doesn't seem like mission creep. I have realized that for my use case, `connected_components` is really what I need (assuming that means splitting a graph into connected subgraphs). Not really sure if I can do that here or with any of the alternatives. Basically, I need to find which symbols have an interdependence and in what order, so first split into subgraphs, then for each order them (where I thought that this solved, at least, the first problem). So `V = [a, b, c]`, `E = [(b, a)]` would return something like `[[b, a], [c]]` (I'm not saying that I want someone to write this for me, but I cannot really figure out if any of the options above can do that...) Yeah, so if you have an undirected graph (edges are symmetric) then connected_components is what you want. Maybe I should just add all three functions. There is directionality in the graph, but assuming that I can split it using this I can order it later. I think that it can be useful, yes. I also assume that separating sets of equations etc can be one use case. I do not know how the "repetitive substitution" works know but I assume that it may be that one can order the equations in a more sensible way using this (and split into independent sets of equations to solve in case that happens). I do not really think overhead is a problem here. At least not for the cases I am considering. And since it is asymptotically linear it should be marginal improvements anyway. (If it is, one can write a specialized version later...) I've changed this to two functions `strongly_connected_components` and `connected_components` (which uses the former as its implementation). </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/utilities/iterables.py] (definition of strongly_connected_components:) def strongly_connected_components(G): """Strongly connected components of a directed graph in reverse topological order. Parameters ========== graph : tuple[list, list[tuple[T, T]] A tuple consisting of a list of vertices and a list of edges of a graph whose strongly connected components are to be found. Examples ======== Consider a directed graph (in dot notation):: digraph { A -> B A -> C B -> C C -> B B -> D } where vertices are the letters A, B, C and D. This graph can be encoded using Python's elementary data structures as follows:: >>> V = ['A', 'B', 'C', 'D'] >>> E = [('A', 'B'), ('A', 'C'), ('B', 'C'), ('C', 'B'), ('B', 'D')] The strongly connected components of this graph can be computed as >>> from sympy.utilities.iterables import strongly_connected_components >>> strongly_connected_components((V, E)) [['D'], ['B', 'C'], ['A']] This also gives the components in reverse topological order. Since the subgraph containing B and C has a cycle they must be together in a strongly connected component. A and D are connected to the rest of the graph but not in a cyclic manner so they appear as their own strongly connected components. Notes ===== The vertices of the graph must be hashable for the data structures used. If the vertices are unhashable replace them with integer indices. This function uses Tarjan's algorithm to compute the strongly connected components in `O(|V|+|E|)` (linear) time. References ========== .. [1] https://en.wikipedia.org/wiki/Strongly_connected_component .. [2] https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm See Also ======== utilities.iterables.connected_components()""" (definition of strongly_connected_components.start:) def start(v): (definition of strongly_connected_components.finish:) def finish(v1): (definition of connected_components:) def connected_components(G): """Connected components of an undirected graph or weakly connected components of a directed graph. Parameters ========== graph : tuple[list, list[tuple[T, T]] A tuple consisting of a list of vertices and a list of edges of a graph whose connected components are to be found. Examples ======== Given an undirected graph:: graph { A -- B C -- D } We can find the connected components using this function if we include each edge in both directions:: >>> from sympy.utilities.iterables import connected_components >>> V = ['A', 'B', 'C', 'D'] >>> E = [('A', 'B'), ('B', 'A'), ('C', 'D'), ('D', 'C')] >>> connected_components((V, E)) [['A', 'B'], ['C', 'D']] The weakly connected components of a directed graph can found the same way. Notes ===== The vertices of the graph must be hashable for the data structures used. If the vertices are unhashable replace them with integer indices. This function uses Tarjan's algorithm to compute the connected components in `O(|V|+|E|)` (linear) time. References ========== .. [1] https://en.wikipedia.org/wiki/Connected_component_(graph_theory) .. [2] https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm See Also ======== utilities.iterables.strongly_connected_components()""" [end of new definitions in sympy/utilities/iterables.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Graph theoretic algorithms for internal use (e.g. Tarjan's algorithm) I have thought of a couple of patches that would benefit from having algorithms for e.g. finding connected components of a graph. Do any graphs theoretic algorithms exist anywhere for internal use in SymPy? I see #8186 rejects the idea of adding a graph theory module for external use but this is about internal use. I have two examples: 1. Given a system of ODEs we can define a directed graph where the variables are the vertices and an equation involving f_i(x).diff(x) and f_j(x) is an edge from i to j. The weakly connected components of this graph represent subsets of the system of equations that can be solved independently. The strongly connected components represent the coupled systems of ODEs that have to be solved as units. 2. Eigenvalues of block diagonal or block diagonal permuted matrices. Viewing a matrix as an adjacency matrix we can partition the row/col indices into ~strongly~ connected components. Those ~strongly~ connected components can be solved as reduced problems in a divide and conquer style approach. This would give a significant performance boost for many matrices. For these two it would be useful to have e.g. Tarjan's algorithm: [https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm](https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm) I'm opening this issue to ask: 1. Does this already exist in SymPy? 2. If not is there a good place to put it? 3. Are there other parts of SymPy that could benefit from something like this? ---------- We have `topological_sort`, which is useful in several places. If a graph algorithm is needed for some library code we should implement it. Tarjan's algorithm, like the topological sort algorithm, doesn't seem that complicated, but it would be useful to implement it in one place. Can the algorithm you describe for ODEs apply to solving regular systems of equations as well? It could be used for regular systems of equations but there we would have undirected graphs. So the idea would be that given ``` a + b = 2 a - b = 1 c + d = 1 c - d = 2 ``` we could partition that into two subproblems for (a,b) and (c,d). I'm not sure how useful that wold be or if it already happens. In the case of ODEs we can do the same but we can also go a step further since for ODEs we have a directed graph so given: ``` f(t).diff(t) = 1 g(t).diff(t) = f(t) + h(t) h(t).diff(t) = g(t) + f(t) z(t).diff(t) = h(t) ``` We can identify that (g,h) is a strongly connected component that must be solved as a unit. The variable f is not disconnected from the graph but is not in a strongly connected component with any other variables so that ODE can be solved independently. Once we've solved for f we can eliminate it from the equations for g,h. Then they can be solved as a separate system. Once we have the solution for h the equation for z becomes a single ODE that can be solved independently. For the ODE module this could greatly expand the number of systems that are matched since we only need to match the strongly connected components of the system. Making use of it needs good support for non-homogeneous / non-autonomous systems though. Ah. So this actually combines nicely with topological_sort, since the strongly connected components create a DAG. The topological_sort tells you what order to solve the sub-systems in. Although apparently Tarjan's algorithm already returns the components in (reverse) topological order). I suspect many places that use topological_sort could be using this instead, as a more generalized way to handle graphs with cycles. For example you can topologically sort a substitution, to make it happen "in order". https://github.com/sympy/sympy/issues/6257 If there's a cycle, like `expr.subs({x: y, y: z})`, it fails. But maybe this can be generalized to finding the strongly connected components and substituting each strongly connected component with simultaneous=True, doing each component in topological order. I would describe `expr.subs({x: y, y: z})` as a chain rather than a cycle. We could certainly partition the substitutions into strongly connected components. Would those components be unambiguous though. What about something where one replacement expression appear in another e.g. `expr.subs({x:y, exp(x):z})`? I think something similar can be used when evaluating summations with symbols in the limits, see #15767 where one approach is to reorder the summation order. (Which will not solve the issue at hand, but still can be useful if deciding to do an explicit evaluation as it may split it into several independent summations/evaluations.) Edit: and therefore also integrals with symbols in the limits, although I do not know if there is a similar issue there. > We could certainly partition the substitutions into strongly connected components. Would those components be unambiguous though. What about something where one replacement expression appear in another e.g. expr.subs({x:y, exp(x):z})? I hadn't thought about that. Maybe you would also need an edge if one term's "old" also contains another's. I'm mostly thinking out loud with this idea. I don't know if it is a good one, just trying to think of ways this algorithm could be useful. Here's an implementation of Tarjan's algorithm: ```python def strongly_connected_components(vertices, edgefunc): '''Strongly connected components of a graph vertices is an iterable giving the vertices of the graph. edgefunc(vertex) gives an iterable of vertices that have edges from vertex. ''' def follow(v1): # Add to the data structures index = len(stack) indices[v1] = lowlink[v1] = index stack.append(v1) # Recurse over descendants for v2 in edgefunc(v1): if v2 not in indices: follow(v2) lowlink[v1] = min(lowlink[v1], lowlink[v2]) elif v2 in stack: lowlink[v1] = min(lowlink[v1], indices[v2]) # Pop off complete connected components if lowlink[v1] == indices[v1]: component = [stack.pop()] while component[-1] is not v1: component.append(stack.pop()) components.append(component[::-1]) lowlink = {} indices = {} stack = [] components = [] for v in vertices: if v in indices: continue follow(v) return components # This represents a directed graph which in dot notation would look like: # digraph G { # A -> B # A -> C # A -> D # B -> C # C -> B # C -> D # } graph = { 'A': ('B', 'C', 'D'), 'B': ('C'), 'C': ('B', 'D'), 'D': (), } for c in strongly_connected_components(graph, graph.__getitem__): print(c) ``` Output: ```console $ python scc.py ['D'] ['B', 'C'] ['A'] ``` Can it use the same input format as topological_sort. Input format is one thing that a real graph library like networkx will provide more flexibility over, but we should just pick a format that is convenient and use it. Is `min` called over integers or over graph elements? If it's graph elements we should allow to pass a `key` function to it. > Cain it use the same input format as topological_sort. Input format can be easily changed. > Is min called over integers or over graph elements? If it's graph elements we should allow to pass a key > function to it. It is called over integers. Here's a version that takes the same format as topological_sort: ```python from sympy import * def strongly_connected_components(G): '''Strongly connected components of a graph G is a tuple (V, E) with V the vertices and E the edges as (v1, v2) pairs. ''' V, E = G Gmap = {vi: [] for vi in V} for v1, v2 in E: Gmap[v1].append(v2) def follow(v1): # Add to the data structures index = len(stack) indices[v1] = lowlink[v1] = index stack.append(v1) # Recurse over descendants for v2 in Gmap[v1]: if v2 not in indices: follow(v2) lowlink[v1] = min(lowlink[v1], lowlink[v2]) elif v2 in stack: lowlink[v1] = min(lowlink[v1], indices[v2]) # Pop off complete connected components if lowlink[v1] == indices[v1]: component = [stack.pop()] while component[-1] is not v1: component.append(stack.pop()) components.append(component[::-1]) lowlink = {} indices = {} stack = [] components = [] for vi in V: if vi in indices: continue follow(vi) return components # This represents a directed graph which in dot notation would look like: # digraph G { # A -> B # A -> C # A -> D # B -> C # C -> B # C -> D # } V = ['A', 'B', 'C', 'D'] E = [ ('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'C'), ('C', 'B'), ('C', 'D'), ] G = (V, E) for c in strongly_connected_components(G): print(c) ``` Here's an example of how we could use this in solve to partition a system of equations (this is an undirected graph so we're just finding the connected components). The function solve_scc solves a system of equations by first partitioning the system into connected components and is faster than solve. ```python def solve_scc(eqs, syms): # Build graph V = syms E = [] # Map back from syms to eqs eqmap = {s:set() for s in syms} for eq in eqs: eqsyms = eq.free_symbols & set(syms) for s1 in eqsyms: eqmap[s1].add(eq) for s2 in eqsyms: if s1 is s2: break E.append((s1, s2)) E.append((s2, s1)) G = (V, E) # Find coupled subsystems: coupled_syms = strongly_connected_components(G) # Solve subsystems and combine results soldict = {} for csyms in coupled_syms: ceqs = set.union(*[eqmap[s] for s in csyms]) csol = solve(ceqs, csyms, dict=True) assert len(csol) == 1 soldict.update(csol[0]) return [soldict] # Build a big-ish linear system: Nrep = 5 # Nrep*3 equations syms = symbols('x:%d' % (3*Nrep,)) a, b, c = symbols('a b c') B = Matrix([ [a, b, c], [a, -b, c], [a, b, -c], ]) rhs = [1, 2, 3] * Nrep M = BlockMatrix([[B if i == j else zeros(3, 3) for i in range(Nrep)] for j in range(Nrep)]) M = M.as_explicit() #pprint(M) b = Matrix([[bi] for bi in rhs]) x = Matrix([[si] for si in syms]) eqs = list(M*x - b) #pprint(eqs) import time # Solve with scc_solve: start = time.time() sol_scc = solve_scc(eqs, syms) print('solve_scc:', time.time() - start, 'seconds') # Solve with solve: start = time.time() sol = solve(eqs, syms, dict=True) print('solve:', time.time() - start, 'seconds') ``` Running this the timings are: ```console $ python scc.py solve_scc: 0.47367119789123535 seconds solve: 35.56143808364868 seconds ``` The differences grow as a system like this gets larger (increase Nrep). Solving an NxN linear system is maybe `O(N**3)`. Here we trade a single system of size N for k systems of size N/k which is then `O(N**3/k**2)`. So the improvement is quadratic in the number of subsystems that we can break down to. I think it would make sense to add strongly_connected_components. We both have usecases for it, so go ahead, I would say! -------------------- </issues>

e941ad69638189ea42507331e417b88837357dec

sympy__sympy-16221

16,221

sympy/sympy

1.4

8fc3b3a96b9f982ed6dc8f626129abee36bcda95

2019-03-10T09:11:58Z

diff --git a/sympy/printing/mathematica.py b/sympy/printing/mathematica.py index ca6ab2f556cb..fd01f493a691 100644 --- a/sympy/printing/mathematica.py +++ b/sympy/printing/mathematica.py @@ -160,6 +160,55 @@ def print_dims(): return 'SparseArray[{}, {}]'.format(print_data(), print_dims()) + def _print_ImmutableDenseNDimArray(self, expr): + return self.doprint(expr.tolist()) + + def _print_ImmutableSparseNDimArray(self, expr): + def print_string_list(string_list): + return '{' + ', '.join(a for a in string_list) + '}' + + def to_mathematica_index(*args): + """Helper function to change Python style indexing to + Pathematica indexing. + + Python indexing (0, 1 ... n-1) + -> Mathematica indexing (1, 2 ... n) + """ + return tuple(i + 1 for i in args) + + def print_rule(pos, val): + """Helper function to print a rule of Mathematica""" + return '{} -> {}'.format(self.doprint(pos), self.doprint(val)) + + def print_data(): + """Helper function to print data part of Mathematica + sparse array. + + It uses the fourth notation ``SparseArray[data,{d1,d2,…}]`` + from + https://reference.wolfram.com/language/ref/SparseArray.html + + ``data`` must be formatted with rule. + """ + return print_string_list( + [print_rule( + to_mathematica_index(*(expr._get_tuple_index(key))), + value) + for key, value in sorted(expr._sparse_array.items())] + ) + + def print_dims(): + """Helper function to print dimensions part of Mathematica + sparse array. + + It uses the fourth notation ``SparseArray[data,{d1,d2,…}]`` + from + https://reference.wolfram.com/language/ref/SparseArray.html + """ + return self.doprint(expr.shape) + + return 'SparseArray[{}, {}]'.format(print_data(), print_dims()) + def _print_Function(self, expr): if expr.func.__name__ in self.known_functions: cond_mfunc = self.known_functions[expr.func.__name__]

diff --git a/sympy/printing/tests/test_mathematica.py b/sympy/printing/tests/test_mathematica.py index 6f2210f51ddb..ad7658b2fd47 100644 --- a/sympy/printing/tests/test_mathematica.py +++ b/sympy/printing/tests/test_mathematica.py @@ -113,6 +113,58 @@ def test_matrices(): assert mcode(MutableDenseMatrix(3, 0, [])) == '{{}, {}, {}}' assert mcode(MutableSparseMatrix(3, 0, [])) == 'SparseArray[{}, {3, 0}]' +def test_NDArray(): + from sympy.tensor.array import ( + MutableDenseNDimArray, ImmutableDenseNDimArray, + MutableSparseNDimArray, ImmutableSparseNDimArray) + + example = MutableDenseNDimArray( + [[[1, 2, 3, 4], + [5, 6, 7, 8], + [9, 10, 11, 12]], + [[13, 14, 15, 16], + [17, 18, 19, 20], + [21, 22, 23, 24]]] + ) + + assert mcode(example) == \ + "{{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}, " \ + "{{13, 14, 15, 16}, {17, 18, 19, 20}, {21, 22, 23, 24}}}" + + example = ImmutableDenseNDimArray(example) + + assert mcode(example) == \ + "{{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}, " \ + "{{13, 14, 15, 16}, {17, 18, 19, 20}, {21, 22, 23, 24}}}" + + example = MutableSparseNDimArray(example) + + assert mcode(example) == \ + "SparseArray[{" \ + "{1, 1, 1} -> 1, {1, 1, 2} -> 2, {1, 1, 3} -> 3, " \ + "{1, 1, 4} -> 4, {1, 2, 1} -> 5, {1, 2, 2} -> 6, " \ + "{1, 2, 3} -> 7, {1, 2, 4} -> 8, {1, 3, 1} -> 9, " \ + "{1, 3, 2} -> 10, {1, 3, 3} -> 11, {1, 3, 4} -> 12, " \ + "{2, 1, 1} -> 13, {2, 1, 2} -> 14, {2, 1, 3} -> 15, " \ + "{2, 1, 4} -> 16, {2, 2, 1} -> 17, {2, 2, 2} -> 18, " \ + "{2, 2, 3} -> 19, {2, 2, 4} -> 20, {2, 3, 1} -> 21, " \ + "{2, 3, 2} -> 22, {2, 3, 3} -> 23, {2, 3, 4} -> 24" \ + "}, {2, 3, 4}]" + + example = ImmutableSparseNDimArray(example) + + assert mcode(example) == \ + "SparseArray[{" \ + "{1, 1, 1} -> 1, {1, 1, 2} -> 2, {1, 1, 3} -> 3, " \ + "{1, 1, 4} -> 4, {1, 2, 1} -> 5, {1, 2, 2} -> 6, " \ + "{1, 2, 3} -> 7, {1, 2, 4} -> 8, {1, 3, 1} -> 9, " \ + "{1, 3, 2} -> 10, {1, 3, 3} -> 11, {1, 3, 4} -> 12, " \ + "{2, 1, 1} -> 13, {2, 1, 2} -> 14, {2, 1, 3} -> 15, " \ + "{2, 1, 4} -> 16, {2, 2, 1} -> 17, {2, 2, 2} -> 18, " \ + "{2, 2, 3} -> 19, {2, 2, 4} -> 20, {2, 3, 1} -> 21, " \ + "{2, 3, 2} -> 22, {2, 3, 3} -> 23, {2, 3, 4} -> 24" \ + "}, {2, 3, 4}]" + def test_Integral(): assert mcode(Integral(sin(sin(x)), x)) == "Hold[Integrate[Sin[Sin[x]], x]]"

[ { "components": [ { "doc": "", "lines": [ 163, 164 ], "name": "MCodePrinter._print_ImmutableDenseNDimArray", "signature": "def _print_ImmutableDenseNDimArray(self, expr):", "type": "function" }, { "doc": "", "l...

[ "test_NDArray" ]

[ "test_Integer", "test_Rational", "test_Function", "test_Pow", "test_Mul", "test_constants", "test_containers", "test_matrices", "test_Integral", "test_Derivative", "test_Sum" ]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Printing : N-Dimensional Array for Mathematica  #### References to other Issues or PRs  Fixes #15618 #### Brief description of what is fixed or changed Finally, I have added NDArrays for mathematica printers. Though some helper functions are duplicate to the implementation in #15792, I left some boilerplates before any good way to support Mathematica's rules system, strings, or such are discovered. Reference for mathematica sparse array https://reference.wolfram.com/language/ref/SparseArray.html #### Other comments #### Release Notes   - printing - Added support for `DenseNDimArray` and `SparseNDimArray` for `mathematica_code`  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/printing/mathematica.py] (definition of MCodePrinter._print_ImmutableDenseNDimArray:) def _print_ImmutableDenseNDimArray(self, expr): (definition of MCodePrinter._print_ImmutableSparseNDimArray:) def _print_ImmutableSparseNDimArray(self, expr): (definition of MCodePrinter._print_ImmutableSparseNDimArray.print_string_list:) def print_string_list(string_list): (definition of MCodePrinter._print_ImmutableSparseNDimArray.to_mathematica_index:) def to_mathematica_index(*args): """Helper function to change Python style indexing to Pathematica indexing. Python indexing (0, 1 ... n-1) -> Mathematica indexing (1, 2 ... n)""" (definition of MCodePrinter._print_ImmutableSparseNDimArray.print_rule:) def print_rule(pos, val): """Helper function to print a rule of Mathematica""" (definition of MCodePrinter._print_ImmutableSparseNDimArray.print_data:) def print_data(): """Helper function to print data part of Mathematica sparse array. It uses the fourth notation ``SparseArray[data,{d1,d2,…}]`` from https://reference.wolfram.com/language/ref/SparseArray.html ``data`` must be formatted with rule.""" (definition of MCodePrinter._print_ImmutableSparseNDimArray.print_dims:) def print_dims(): """Helper function to print dimensions part of Mathematica sparse array. It uses the fourth notation ``SparseArray[data,{d1,d2,…}]`` from https://reference.wolfram.com/language/ref/SparseArray.html""" [end of new definitions in sympy/printing/mathematica.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Mathematica code: allow printing of matrices and arrays. Our printers for Wolfram Mathematica do not support matrices and arrays. We should add support for it. ---------- -------------------- </issues>

e941ad69638189ea42507331e417b88837357dec

sympy__sympy-16209

16,209

sympy/sympy

1.4

00252f18af78cdc3013042e7ef264af8161c9366

2019-03-09T09:07:04Z

diff --git a/sympy/matrices/matrices.py b/sympy/matrices/matrices.py index b0efd9dc4278..d44f73ae4dc8 100644 --- a/sympy/matrices/matrices.py +++ b/sympy/matrices/matrices.py @@ -4260,6 +4260,100 @@ def QRsolve(self, b): x.append(tmp / R[j, j]) return self._new([row._mat for row in reversed(x)]) + def rank_decomposition(self, iszerofunc=_iszero, simplify=False): + r"""Returns a pair of matrices (`C`, `F`) with matching rank + such that `A = C F`. + + Parameters + ========== + + iszerofunc : Function, optional + A function used for detecting whether an element can + act as a pivot. ``lambda x: x.is_zero`` is used by default. + + simplify : Bool or Function, optional + A function used to simplify elements when looking for a + pivot. By default SymPy's ``simplify`` is used. + + Returns + ======= + + (C, F) : Matrices + `C` and `F` are full-rank matrices with rank as same as `A`, + whose product gives `A`. + + See Notes for additional mathematical details. + + Examples + ======== + + >>> from sympy.matrices import Matrix + >>> A = Matrix([ + ... [1, 3, 1, 4], + ... [2, 7, 3, 9], + ... [1, 5, 3, 1], + ... [1, 2, 0, 8] + ... ]) + >>> C, F = A.rank_decomposition() + >>> C + Matrix([ + [1, 3, 4], + [2, 7, 9], + [1, 5, 1], + [1, 2, 8]]) + >>> F + Matrix([ + [1, 0, -2, 0], + [0, 1, 1, 0], + [0, 0, 0, 1]]) + >>> C * F == A + True + + Notes + ===== + + Obtaining `F`, an RREF of `A`, is equivalent to creating a + product + + .. math:: + E_n E_{n-1} ... E_1 A = F + + where `E_n, E_{n-1}, ... , E_1` are the elimination matrices or + permutation matrices equivalent to each row-reduction step. + + The inverse of the same product of elimination matrices gives + `C`: + + .. math:: + C = (E_n E_{n-1} ... E_1)^{-1} + + It is not necessary, however, to actually compute the inverse: + the columns of `C` are those from the original matrix with the + same column indices as the indices of the pivot columns of `F`. + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Rank_factorization + + .. [2] Piziak, R.; Odell, P. L. (1 June 1999). + "Full Rank Factorization of Matrices". + Mathematics Magazine. 72 (3): 193. doi:10.2307/2690882 + + See Also + ======== + + rref + """ + (F, pivot_cols) = self.rref( + simplify=simplify, iszerofunc=iszerofunc, pivots=True) + rank = len(pivot_cols) + + C = self.extract(range(self.rows), pivot_cols) + F = F[:rank, :] + + return (C, F) + def solve_least_squares(self, rhs, method='CH'): """Return the least-square fit to the data.

diff --git a/sympy/matrices/tests/test_matrices.py b/sympy/matrices/tests/test_matrices.py index f6f78c6e22d8..fc8d49a4ff35 100644 --- a/sympy/matrices/tests/test_matrices.py +++ b/sympy/matrices/tests/test_matrices.py @@ -3304,6 +3304,34 @@ def test_iszero_substitution(): # if a zero-substitution wasn't made, this entry will be -1.11022302462516e-16 assert m_rref[2,2] == 0 +def test_rank_decomposition(): + a = Matrix(0, 0, []) + c, f = a.rank_decomposition() + assert f.is_echelon + assert c.cols == f.rows == a.rank() + assert c * f == a + + a = Matrix(1, 1, [5]) + c, f = a.rank_decomposition() + assert f.is_echelon + assert c.cols == f.rows == a.rank() + assert c * f == a + + a = Matrix(3, 3, [1, 2, 3, 1, 2, 3, 1, 2, 3]) + c, f = a.rank_decomposition() + assert f.is_echelon + assert c.cols == f.rows == a.rank() + assert c * f == a + + a = Matrix([ + [0, 0, 1, 2, 2, -5, 3], + [-1, 5, 2, 2, 1, -7, 5], + [0, 0, -2, -3, -3, 8, -5], + [-1, 5, 0, -1, -2, 1, 0]]) + c, f = a.rank_decomposition() + assert f.is_echelon + assert c.cols == f.rows == a.rank() + assert c * f == a @slow def test_issue_11238():

[ { "components": [ { "doc": "Returns a pair of matrices (`C`, `F`) with matching rank\nsuch that `A = C F`.\n\nParameters\n==========\n\niszerofunc : Function, optional\n A function used for detecting whether an element can\n act as a pivot. ``lambda x: x.is_zero`` is used by default.\n\nsim...

[ "test_rank_decomposition" ]

[ "test_args", "test_division", "test_sum", "test_abs", "test_addition", "test_fancy_index_matrix", "test_multiplication", "test_power", "test_creation", "test_tolist", "test_as_mutable", "test_determinant", "test_slicing", "test_submatrix_assignment", "test_extract", "test_reshape", "...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Matrices : Add rank factorization  #### References to other Issues or PRs  #### Brief description of what is fixed or changed https://en.wikipedia.org/wiki/Rank_factorization Similarly to gaussian elimination introducing LU decomposition, gauss-jordan elimination introduces rank decomposition, and it can be easily computed by taking the pivot columns of the original matrix. Though I rarely see this feature implemented in most computer algebra or numeric analysis softwares. I have added under `MatrixReductions` class, but still I think most of the decomposition methods are uncategorized in `MatrixBase`. <img src=https://user-images.githubusercontent.com/34944973/54493462-ba480880-4913-11e9-91ff-6b869a3654f9.png width="512px"> #### Other comments #### Release Notes   - matrices - Added a new function ``rank_decomposition``.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/matrices/matrices.py] (definition of MatrixBase.rank_decomposition:) def rank_decomposition(self, iszerofunc=_iszero, simplify=False): """Returns a pair of matrices (`C`, `F`) with matching rank such that `A = C F`. Parameters ========== iszerofunc : Function, optional A function used for detecting whether an element can act as a pivot. ``lambda x: x.is_zero`` is used by default. simplify : Bool or Function, optional A function used to simplify elements when looking for a pivot. By default SymPy's ``simplify`` is used. Returns ======= (C, F) : Matrices `C` and `F` are full-rank matrices with rank as same as `A`, whose product gives `A`. See Notes for additional mathematical details. Examples ======== >>> from sympy.matrices import Matrix >>> A = Matrix([ ... [1, 3, 1, 4], ... [2, 7, 3, 9], ... [1, 5, 3, 1], ... [1, 2, 0, 8] ... ]) >>> C, F = A.rank_decomposition() >>> C Matrix([ [1, 3, 4], [2, 7, 9], [1, 5, 1], [1, 2, 8]]) >>> F Matrix([ [1, 0, -2, 0], [0, 1, 1, 0], [0, 0, 0, 1]]) >>> C * F == A True Notes ===== Obtaining `F`, an RREF of `A`, is equivalent to creating a product .. math:: E_n E_{n-1} ... E_1 A = F where `E_n, E_{n-1}, ... , E_1` are the elimination matrices or permutation matrices equivalent to each row-reduction step. The inverse of the same product of elimination matrices gives `C`: .. math:: C = (E_n E_{n-1} ... E_1)^{-1} It is not necessary, however, to actually compute the inverse: the columns of `C` are those from the original matrix with the same column indices as the indices of the pivot columns of `F`. References ========== .. [1] https://en.wikipedia.org/wiki/Rank_factorization .. [2] Piziak, R.; Odell, P. L. (1 June 1999). "Full Rank Factorization of Matrices". Mathematics Magazine. 72 (3): 193. doi:10.2307/2690882 See Also ======== rref""" [end of new definitions in sympy/matrices/matrices.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

e941ad69638189ea42507331e417b88837357dec

joke2k__faker-919

919

joke2k/faker

null

9649c8d86e0baf8bc4fd33ba8661847ec33a62e1

2019-03-08T12:26:15Z

diff --git a/faker/providers/ssn/pt_BR/__init__.py b/faker/providers/ssn/pt_BR/__init__.py index 028637f21d..01e33307a1 100644 --- a/faker/providers/ssn/pt_BR/__init__.py +++ b/faker/providers/ssn/pt_BR/__init__.py @@ -1,6 +1,7 @@ # coding=utf-8 from __future__ import unicode_literals + from .. import Provider as SsnProvider @@ -44,3 +45,22 @@ def ssn(self): def cpf(self): c = self.ssn() return c[:3] + '.' + c[3:6] + '.' + c[6:9] + '-' + c[9:] + + def rg(self): + """ + Brazilian RG, return plain numbers. + Check: https://www.ngmatematica.com/2014/02/como-determinar-o-digito-verificador-do.html + """ + + digits = self.generator.random.sample(range(0, 9), 8) + checksum = sum(i * digits[i - 2] for i in range(2, 10)) + last_digit = 11 - (checksum % 11) + + if last_digit == 10: + digits.append('X') + elif last_digit == 11: + digits.append(0) + else: + digits.append(last_digit) + + return ''.join(map(str, digits))

diff --git a/tests/providers/test_ssn.py b/tests/providers/test_ssn.py index 0e09f3f895..1955ae60c7 100644 --- a/tests/providers/test_ssn.py +++ b/tests/providers/test_ssn.py @@ -423,6 +423,14 @@ def test_pt_BR_cpf(self): for _ in range(100): assert re.search(r'\d{3}\.\d{3}\.\d{3}-\d{2}', self.factory.cpf()) + def test_pt_BR_rg(self): + for _ in range(100): + to_test = self.factory.rg() + if 'X' in to_test: + assert re.search(r'^\d{8}X', to_test) + else: + assert re.search(r'^\d{9}$', to_test) + class TestNlNL(unittest.TestCase): def setUp(self):

[ { "components": [ { "doc": "Brazilian RG, return plain numbers.\nCheck: https://www.ngmatematica.com/2014/02/como-determinar-o-digito-verificador-do.html", "lines": [ 49, 66 ], "name": "Provider.rg", "signature": "def rg(self):", "type":...

[ "tests/providers/test_ssn.py::TestPtBR::test_pt_BR_rg" ]

[ "tests/providers/test_ssn.py::TestBgBG::test_vat_id", "tests/providers/test_ssn.py::TestCsCZ::test_vat_id", "tests/providers/test_ssn.py::TestDeAT::test_vat_id", "tests/providers/test_ssn.py::TestElCY::test_vat_id", "tests/providers/test_ssn.py::TestEnCA::test_ssn", "tests/providers/test_ssn.py::TestEnUS:...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Brazilian RG Feature ### What does this changes Address Brazilian RG (identity card) ### What was wrong New feature ### How this fixes it Fixes #918 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in faker/providers/ssn/pt_BR/__init__.py] (definition of Provider.rg:) def rg(self): """Brazilian RG, return plain numbers. Check: https://www.ngmatematica.com/2014/02/como-determinar-o-digito-verificador-do.html""" [end of new definitions in faker/providers/ssn/pt_BR/__init__.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Brazilian RG (identity card) Add Generator to Brazilian RG (identity card) ### Steps to reproduce fake = Faker('pt_Br') fake.rg() ### Expected behavior return like this rules: https://www.ngmatematica.com/2014/02/como-determinar-o-digito-verificador-do.html 8 digits + 1 checksum digit ### Actual behavior New feature ---------- -------------------- </issues>

6edfdbf6ae90b0153309e3bf066aa3b2d16494a7

sympy__sympy-16199

16,199

sympy/sympy

1.4

34482a7071422e5766a16a0370fa12f9a0b7c8e0

2019-03-08T06:00:41Z

diff --git a/sympy/vector/__init__.py b/sympy/vector/__init__.py index fccb4e4d14a1..2493bff5c945 100644 --- a/sympy/vector/__init__.py +++ b/sympy/vector/__init__.py @@ -13,4 +13,4 @@ from sympy.vector.point import Point from sympy.vector.orienters import (AxisOrienter, BodyOrienter, SpaceOrienter, QuaternionOrienter) -from sympy.vector.operators import Gradient, Divergence, Curl, gradient, curl, divergence +from sympy.vector.operators import Gradient, Divergence, Curl, Laplacian, gradient, curl, divergence diff --git a/sympy/vector/functions.py b/sympy/vector/functions.py index 574ec39f11e2..fb7f1ead08e1 100644 --- a/sympy/vector/functions.py +++ b/sympy/vector/functions.py @@ -198,6 +198,7 @@ def laplacian(expr): 2*R.i + 6*R.y*R.j + 12*R.z**2*R.k """ + delop = Del() if expr.is_Vector: return (gradient(divergence(expr)) - curl(curl(expr))).doit() diff --git a/sympy/vector/operators.py b/sympy/vector/operators.py index 72231fa1d581..bc677f5e60c6 100644 --- a/sympy/vector/operators.py +++ b/sympy/vector/operators.py @@ -327,6 +327,32 @@ def gradient(scalar_field, coord_sys=None, doit=True): return Gradient(scalar_field) +class Laplacian(Expr): + """ + Represents unevaluated Laplacian. + + Examples + ======== + + >>> from sympy.vector import CoordSys3D, Laplacian + >>> R = CoordSys3D('R') + >>> v = 3*R.x**3*R.y**2*R.z**3 + >>> Laplacian(v) + Laplacian(3*R.x**3*R.y**2*R.z**3) + + """ + + def __new__(cls, expr): + expr = sympify(expr) + obj = Expr.__new__(cls, expr) + obj._expr = expr + return obj + + def doit(self, **kwargs): + from sympy.vector.functions import laplacian + return laplacian(self._expr) + + def _diff_conditional(expr, base_scalar, coeff_1, coeff_2): """ First re-expresses expr in the system that base_scalar belongs to.

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index 5895f1ca842c..2228bea932bd 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -4522,6 +4522,13 @@ def test_sympy__vector__operators__Curl(): assert _test_args(Curl(C.i)) +def test_sympy__vector__operators__Laplacian(): + from sympy.vector.operators import Laplacian + from sympy.vector.coordsysrect import CoordSys3D + C = CoordSys3D('C') + assert _test_args(Laplacian(C.i)) + + def test_sympy__vector__operators__Divergence(): from sympy.vector.operators import Divergence from sympy.vector.coordsysrect import CoordSys3D diff --git a/sympy/vector/tests/test_operators.py b/sympy/vector/tests/test_operators.py index 0ec64fe17377..236298f64eda 100644 --- a/sympy/vector/tests/test_operators.py +++ b/sympy/vector/tests/test_operators.py @@ -1,11 +1,13 @@ -from sympy.vector import CoordSys3D, Gradient, Divergence, Curl, VectorZero - +from sympy.vector import CoordSys3D, Gradient, Divergence, Curl, VectorZero, Laplacian +from sympy.printing.repr import srepr R = CoordSys3D('R') s1 = R.x*R.y*R.z s2 = R.x + 3*R.y**2 +s3 = R.x**2 + R.y**2 + R.z**2 v1 = R.x*R.i + R.z*R.z*R.j v2 = R.x*R.i + R.y*R.j + R.z*R.k +v3 = R.x**2*R.i + R.y**2*R.j + R.z**2*R.k def test_Gradient(): @@ -27,3 +29,12 @@ def test_Curl(): assert Curl(v2) == Curl(R.x*R.i + R.y*R.j + R.z*R.k) assert Curl(v1).doit() == (-2*R.z)*R.i assert Curl(v2).doit() == VectorZero() + + +def test_Laplacian(): + assert Laplacian(s3) == Laplacian(R.x**2 + R.y**2 + R.z**2) + assert Laplacian(v3) == Laplacian(R.x**2*R.i + R.y**2*R.j + R.z**2*R.k) + assert Laplacian(s3).doit() == 6 + assert Laplacian(v3).doit() == 2*R.i + 2*R.j + 2*R.k + assert srepr(Laplacian(s3)) == \ + 'Laplacian(Add(Pow(R.x, Integer(2)), Pow(R.y, Integer(2)), Pow(R.z, Integer(2))))'

[ { "components": [ { "doc": "Represents unevaluated Laplacian.\n\nExamples\n========\n\n>>> from sympy.vector import CoordSys3D, Laplacian\n>>> R = CoordSys3D('R')\n>>> v = 3*R.x**3*R.y**2*R.z**3\n>>> Laplacian(v)\nLaplacian(3*R.x**3*R.y**2*R.z**3)", "lines": [ 330, 353 ...

[ "test_sympy__vector__operators__Laplacian", "test_Gradient", "test_Divergence", "test_Curl" ]

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added class to represent unevaluated laplacian.  #### References to other Issues or PRs  Fixes #13664 #### Brief description of what is fixed or changed `Laplacian` class added to represent unevaluated Laplacian in `vector/operators.py`. ``` >>> from sympy.vector import Laplacian, CoordSys3D >>> R = CoordSys3D('R') >>> v = R.x**3 + R.y**3 + R.z**3 >>> Laplacian(v) Laplacian(R.x**3 + R.y**3 + R.z**3) >>> Laplacian(v).doit() 6*R.x + 6*R.y + 6*R.z ``` #### Other comments #### Release Notes   * vector * added Laplacian class to represent unevaluated laplacian.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/vector/operators.py] (definition of Laplacian:) class Laplacian(Expr): """Represents unevaluated Laplacian. Examples ======== >>> from sympy.vector import CoordSys3D, Laplacian >>> R = CoordSys3D('R') >>> v = 3*R.x**3*R.y**2*R.z**3 >>> Laplacian(v) Laplacian(3*R.x**3*R.y**2*R.z**3)""" (definition of Laplacian.__new__:) def __new__(cls, expr): (definition of Laplacian.doit:) def doit(self, **kwargs): [end of new definitions in sympy/vector/operators.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Full support of laplacian in vector package In #12261 `laplacian` function was added. I think that it could be good idea to add to `vector` package full support of `laplacian` operator like it is done for `del` operator. For example support for `laplacian` may looks: ```python C = CoordSys3D('C') i, j, k = C.base_vectors() x, y, z = C.base_scalars() delop = Del() lap = Laplacian() v = x*y**2 v1 = delop(v)).doit() # C.y**2*C.i + 2*C.x*C.y*C.j delop & v1 # 2*C.x lap * v2 # 2*C.x, not sure if this operator is the best here ``` Another advantage of adding `laplacian` is better looking of unevaluated latex form. Instead of printing `del` twice we have one `delta` symbol. @Upabjojr, @gxyd, what do you think? I'd like to work on this issue. ---------- `lap = Laplacian()` I don't really like the idea of overloading the `*` operator in general (it makes everything so confused when parsing _Mul_ expressions). I think it's best to use the name _Laplacian_ for unevaluated expressions, and use the function call `( )` for the operator application. > use the function call ( ) for the operator application. I might agree with you, but shouldn't it introduce discrepancy between `laplacian` and `del` operators? I mean, for `del` we have operator itself (`Del()`) and *acting* operator (`gradient(...)`, `curl(...)`, etc.), but for `laplacian` only *acting* operator. What do you think? We already have a `Del()` operator, the Laplacian could be represented by adding `_eval_power` or something similar to `Del`. -------------------- </issues>

e941ad69638189ea42507331e417b88837357dec

sympy__sympy-16194

16,194

sympy/sympy

1.4

0e987498b00167fdd4a08a41c852a97cb70ce8f2

2019-03-07T18:13:37Z

diff --git a/sympy/logic/boolalg.py b/sympy/logic/boolalg.py index e5cc6f680ba4..d81832e84711 100644 --- a/sympy/logic/boolalg.py +++ b/sympy/logic/boolalg.py @@ -719,6 +719,9 @@ def _eval_as_set(self): from sympy.sets.sets import Intersection return Intersection(*[arg.as_set() for arg in self.args]) + def _eval_rewrite_as_Nor(self, *args, **kwargs): + return Nor(*[Not(arg) for arg in self.args]) + class Or(LatticeOp, BooleanFunction): """ @@ -772,6 +775,9 @@ def _eval_as_set(self): from sympy.sets.sets import Union return Union(*[arg.as_set() for arg in self.args]) + def _eval_rewrite_as_Nand(self, *args, **kwargs): + return Nand(*[Not(arg) for arg in self.args]) + def _eval_simplify(self, ratio, measure, rational, inverse): # standard simplify rv = super(Or, self)._eval_simplify( @@ -1004,6 +1010,16 @@ def to_nnf(self, simplify=True): args.append(Or(*clause)) return And._to_nnf(*args, simplify=simplify) + def _eval_rewrite_as_Or(self, *args, **kwargs): + a = self.args + return Or(*[_convert_to_varsSOP(x, self.args) + for x in _get_odd_parity_terms(len(a))]) + + def _eval_rewrite_as_And(self, *args, **kwargs): + a = self.args + return And(*[_convert_to_varsPOS(x, self.args) + for x in _get_even_parity_terms(len(a))]) + def _eval_simplify(self, ratio, measure, rational, inverse): # as standard simplify uses simplify_logic which writes things as # And and Or, we only simplify the partial expressions before using patterns @@ -1931,6 +1947,32 @@ def _convert_to_varsPOS(maxterm, variables): return Or(*temp) +def _get_odd_parity_terms(n): + """ + Returns a list of lists, with all possible combinations of n zeros and ones + with an odd number of ones. + """ + op = [] + for i in range(1, 2**n): + e = ibin(i, n) + if sum(e) % 2 == 1: + op.append(e) + return op + + +def _get_even_parity_terms(n): + """ + Returns a list of lists, with all possible combinations of n zeros and ones + with an even number of ones. + """ + op = [] + for i in range(2**n): + e = ibin(i, n) + if sum(e) % 2 == 0: + op.append(e) + return op + + def _simplified_pairs(terms): """ Reduces a set of minterms, if possible, to a simplified set of minterms @@ -2035,6 +2077,7 @@ def _input_to_binlist(inputlist, variables): raise TypeError("A term list can only contain lists, ints or dicts.") return binlist + def SOPform(variables, minterms, dontcares=None): """ The SOPform function uses simplified_pairs and a redundant group-

diff --git a/sympy/logic/tests/test_boolalg.py b/sympy/logic/tests/test_boolalg.py index 529a489221ed..e0f04a991ca2 100644 --- a/sympy/logic/tests/test_boolalg.py +++ b/sympy/logic/tests/test_boolalg.py @@ -109,6 +109,26 @@ def test_Xor(): assert Xor(e, e.canonical) == Xor(0, 0) == Xor(1, 1) +def test_rewrite_as_And(): + expr = x ^ y + assert expr.rewrite(And) == (x | y) & (~x | ~y) + + +def test_rewrite_as_Or(): + expr = x ^ y + assert expr.rewrite(Or) == (x & ~y) | (y & ~x) + + +def test_rewrite_as_Nand(): + expr = (y & z) | (z & ~w) + assert expr.rewrite(Nand) == ~(~(y & z) & ~(z & ~w)) + + +def test_rewrite_as_Nor(): + expr = z & (y | ~w) + assert expr.rewrite(Nor) == ~(~z | ~(y | ~w)) + + def test_Not(): raises(TypeError, lambda: Not(True, False)) assert Not(True) is false

[ { "components": [ { "doc": "", "lines": [ 722, 723 ], "name": "And._eval_rewrite_as_Nor", "signature": "def _eval_rewrite_as_Nor(self, *args, **kwargs):", "type": "function" }, { "doc": "", "lines": [ ...

[ "test_rewrite_as_And", "test_rewrite_as_Or", "test_rewrite_as_Nand", "test_rewrite_as_Nor" ]

[ "test_overloading", "test_And", "test_Or", "test_Xor", "test_Not", "test_Nand", "test_Nor", "test_Xnor", "test_Implies", "test_Equivalent", "test_equals", "test_simplification", "test_bool_map", "test_bool_symbol", "test_is_boolean", "test_subs", "test_commutative", "test_and_assoc...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> logic equation suggestions  #### References to other Issues or PRs  #16137 #### Brief description of what is fixed or changed ```expr._rewrite_as_And, expr._rewrite_as_Or, expr._rewrite_as_Nor, expr._rewrite_as_Nand``` added to logic equations. #### Other comments #### Release Notes   * logic * `And` can be rewritten as `Nor`, `Or` as `Nand`, and `Xor` as either `Or`or `And`.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/logic/boolalg.py] (definition of And._eval_rewrite_as_Nor:) def _eval_rewrite_as_Nor(self, *args, **kwargs): (definition of Or._eval_rewrite_as_Nand:) def _eval_rewrite_as_Nand(self, *args, **kwargs): (definition of Xor._eval_rewrite_as_Or:) def _eval_rewrite_as_Or(self, *args, **kwargs): (definition of Xor._eval_rewrite_as_And:) def _eval_rewrite_as_And(self, *args, **kwargs): (definition of _get_odd_parity_terms:) def _get_odd_parity_terms(n): """Returns a list of lists, with all possible combinations of n zeros and ones with an odd number of ones.""" (definition of _get_even_parity_terms:) def _get_even_parity_terms(n): """Returns a list of lists, with all possible combinations of n zeros and ones with an even number of ones.""" [end of new definitions in sympy/logic/boolalg.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

e941ad69638189ea42507331e417b88837357dec

sympy__sympy-16189

16,189

sympy/sympy

1.4

0e987498b00167fdd4a08a41c852a97cb70ce8f2

2019-03-07T10:42:03Z

diff --git a/sympy/core/expr.py b/sympy/core/expr.py index 38bd1d2deffd..cd76f61a87ea 100644 --- a/sympy/core/expr.py +++ b/sympy/core/expr.py @@ -3537,6 +3537,27 @@ def _n2(a, b): return dif +def unchanged(func, *args): + """Return True if `func` applied to the `args` is unchanged. + Can be used instead of `assert foo == foo`. + + Examples + ======== + + >>> from sympy.core.expr import unchanged + >>> from sympy.functions.elementary.trigonometric import cos + >>> from sympy.core.numbers import pi + + >>> unchanged(cos, 1) # instead of assert cos(1) == cos(1) + True + + >>> unchanged(cos, pi) + False + """ + f = func(*args) + return f.func == func and f.args == tuple([sympify(a) for a in args]) + + from .mul import Mul from .add import Add from .power import Pow

diff --git a/sympy/functions/elementary/tests/test_complexes.py b/sympy/functions/elementary/tests/test_complexes.py index d328db8c8e8f..b0568209620b 100644 --- a/sympy/functions/elementary/tests/test_complexes.py +++ b/sympy/functions/elementary/tests/test_complexes.py @@ -5,6 +5,7 @@ Interval, comp, Integral, Matrix, ImmutableMatrix, SparseMatrix, ImmutableSparseMatrix, MatrixSymbol, FunctionMatrix, Lambda, Derivative) from sympy.utilities.pytest import XFAIL, raises +from sympy.core.expr import unchanged def N_equals(a, b): @@ -32,7 +33,7 @@ def test_re(): assert re(E) == E assert re(-E) == -E - assert re(x) == re(x) + assert unchanged(re, x) assert re(x*I) == -im(x) assert re(r*I) == 0 assert re(r) == r @@ -128,7 +129,7 @@ def test_im(): assert im(E*I) == E assert im(-E*I) == -E - assert im(x) == im(x) + assert unchanged(im, x) assert im(x*I) == re(x) assert im(r*I) == r assert im(r) == 0 diff --git a/sympy/polys/tests/test_rootoftools.py b/sympy/polys/tests/test_rootoftools.py index 494094743316..a402b4cd9d81 100644 --- a/sympy/polys/tests/test_rootoftools.py +++ b/sympy/polys/tests/test_rootoftools.py @@ -16,6 +16,7 @@ ) from sympy.utilities.pytest import raises, slow +from sympy.core.expr import unchanged from sympy.core.compatibility import range from sympy.abc import a, b, x, y, z, r @@ -138,11 +139,11 @@ def test_CRootOf___eval_Eq__(): r1 = rootof(eq, 1) assert Eq(r, r1) is S.false assert Eq(r, r) is S.true - assert Eq(r, x).lhs is r and Eq(r, x).rhs is x + assert unchanged(Eq, r, x) assert Eq(r, 0) is S.false assert Eq(r, S.Infinity) is S.false assert Eq(r, I) is S.false - assert Eq(r, f(0)).lhs is r and Eq(r, f(0)).rhs is f(0) + assert unchanged(Eq, r, f(0)) sol = solve(eq) for s in sol: if s.is_real: @@ -572,4 +573,4 @@ def test_eval_approx_relative(): def test_issue_15920(): r = rootof(x**5 - x + 1, 0) p = Integral(x, (x, 1, y)) - assert Eq(r, p).lhs is r and Eq(r, p).rhs is p + assert unchanged(Eq, r, p)

[ { "components": [ { "doc": "Return True if `func` applied to the `args` is unchanged.\nCan be used instead of `assert foo == foo`.\n\nExamples\n========\n\n>>> from sympy.core.expr import unchanged\n>>> from sympy.functions.elementary.trigonometric import cos\n>>> from sympy.core.numbers import pi...

[ "test_re", "test_im", "test_sign", "test_as_real_imag", "test_Abs", "test_Abs_rewrite", "test_Abs_real", "test_Abs_properties", "test_abs", "test_arg", "test_arg_rewrite", "test_adjoint", "test_conjugate", "test_conjugate_transpose", "test_transpose", "test_polarify", "test_unpolarif...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added an unchanged function in utilities Added a function `unchanged` in utilities/misc.py for checking if the expression remains unchanged. Return `True` if unchanged and `False` if changed  #### References to other Issues or PRs  Fixes #16177 #### Brief description of what is fixed or changed Earlier in test cases, `assert foo == foo` was used in many places which really does nothing. After this change, using `assert unchanged(foo)` will give an error if the expression gets simplified. Eg. `unchanged(sin(x))` will come out to be True `unchanged(sin(pi))` will come out to be False as it simplifies to `0` #### Other comments I have added 2 test cases in `functions/tests/test_complexes.py` which used `assert re(x) == re(x)` and `assert im(x) == im(x)` Not sure if I should add more #### Release Notes   * utilities * Added a function `unchanged` which evaluates if expression is changed or not  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/core/expr.py] (definition of unchanged:) def unchanged(func, *args): """Return True if `func` applied to the `args` is unchanged. Can be used instead of `assert foo == foo`. Examples ======== >>> from sympy.core.expr import unchanged >>> from sympy.functions.elementary.trigonometric import cos >>> from sympy.core.numbers import pi >>> unchanged(cos, 1) # instead of assert cos(1) == cos(1) True >>> unchanged(cos, pi) False""" [end of new definitions in sympy/core/expr.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> add function to test for unchanged expression In #2942 there was a lot of discussion about tests that write `assert foo == foo`. An idea that I left there was this function which I still think could be used for cases when you want to assert that what you typed remained unchanged: ```python def unchanged(func, *args): """Return True if `func` applied to the `args` is unchanged. Examples ======== >>> unchanged(cos, 1) # instead of assert cos(1) == cos(1) True """ f = func(*args) return f.func == func and f.args == tuple([sympify(a) for a in args]) ``` ---------- I guess that could be used e.g. here [https://github.com/sympy/sympy/pull/15923#discussion_r262006408](https://github.com/sympy/sympy/pull/15923#discussion_r262006408) I'll take this @smichr @oscarbenjamin should we add this function to `utilities/pytest.py`? We are going to use this method just for testing. Right? Or are we planning to use this method for general purpose (other than testing) as well? It will be just for testing but probably doesn't want to go in pytest.py. The pytest.py file is supposed to be a compatibility layer that either imports functions from pytest or defines them if pytest isn't installed. Since this function isn't defined in pytest it should go somewhere else. I guess I'd put this in utilities/misc.py. -------------------- </issues>

e941ad69638189ea42507331e417b88837357dec

sympy__sympy-16142

16,142

sympy/sympy

1.4

8d8addc912dcef24e759ff8c62ff197cb7052931

2019-03-02T15:38:24Z

diff --git a/sympy/ntheory/__init__.py b/sympy/ntheory/__init__.py index 6d7ca7de9a2a..92c75d343860 100644 --- a/sympy/ntheory/__init__.py +++ b/sympy/ntheory/__init__.py @@ -9,7 +9,7 @@ pollard_pm1, pollard_rho, primefactors, totient, trailing, divisor_count, \ divisor_sigma, factorrat, reduced_totient, primenu, primeomega, \ mersenne_prime_exponent, is_perfect, is_mersenne_prime, is_abundant, \ - is_deficient, abundance + is_deficient, is_amicable, abundance from .partitions_ import npartitions from .residue_ntheory import is_primitive_root, is_quad_residue, \ legendre_symbol, jacobi_symbol, n_order, sqrt_mod, quadratic_residues, \ diff --git a/sympy/ntheory/factor_.py b/sympy/ntheory/factor_.py index 19f3d90985c4..7ffb6d95dbec 100644 --- a/sympy/ntheory/factor_.py +++ b/sympy/ntheory/factor_.py @@ -2201,3 +2201,30 @@ def is_deficient(n): if is_perfect(n): return False return bool(abundance(n) < 0) + + +def is_amicable(m, n): + """Returns True if the numbers `m` and `n` are "amicable", else False. + + Amicable numbers are two different numbers so related that the sum + of the proper divisors of each is equal to that of the other. + + Examples + ======== + + >>> from sympy.ntheory.factor_ import is_amicable, divisor_sigma + >>> is_amicable(220, 284) + True + >>> divisor_sigma(220) == divisor_sigma(284) + True + + References + ========== + + .. [1] https://en.wikipedia.org/wiki/Amicable_numbers + + """ + if m == n: + return False + a, b = map(lambda i: divisor_sigma(i), (m, n)) + return a == b == (m + n)

diff --git a/sympy/ntheory/tests/test_factor_.py b/sympy/ntheory/tests/test_factor_.py index 55e6d207cb89..4c48c4d8d5ab 100644 --- a/sympy/ntheory/tests/test_factor_.py +++ b/sympy/ntheory/tests/test_factor_.py @@ -14,7 +14,7 @@ from sympy.ntheory.factor_ import (smoothness, smoothness_p, antidivisors, antidivisor_count, core, digits, udivisors, udivisor_sigma, udivisor_count, primenu, primeomega, small_trailing, mersenne_prime_exponent, - is_perfect, is_mersenne_prime, is_abundant, is_deficient) + is_perfect, is_mersenne_prime, is_abundant, is_deficient, is_amicable) from sympy.ntheory.generate import cycle_length from sympy.ntheory.multinomial import ( multinomial_coefficients, multinomial_coefficients_iterator) @@ -606,3 +606,9 @@ def test_is_deficient(): assert is_deficient(56) is False assert is_deficient(20) is False assert is_deficient(36) is False + + +def test_is_amicable(): + assert is_amicable(173, 129) is False + assert is_amicable(220, 284) is True + assert is_amicable(8756, 8756) is False

[ { "components": [ { "doc": "Returns True if the numbers `m` and `n` are \"amicable\", else False.\n\nAmicable numbers are two different numbers so related that the sum\nof the proper divisors of each is equal to that of the other.\n\nExamples\n========\n\n>>> from sympy.ntheory.factor_ import is_a...

[ "test_trailing_bitcount", "test_multiplicity", "test_perfect_power", "test_factorint", "test_divisors_and_divisor_count", "test_udivisors_and_udivisor_count", "test_issue_6981", "test_totient", "test_reduced_totient", "test_divisor_sigma", "test_udivisor_sigma", "test_issue_4356", "test_divi...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added Functions for Amicable Number Amicable numbers are two different numbers so related that the sum of the proper divisors of each is equal to the other number. A proper divisor of a number is a positive factor of that number other than the number itself. For example, the proper divisors of 6 are 1, 2, and 3.  #### Brief description of what is fixed or changed Added Functions for Amicable Number with test cases #### Release Notes   - ntheory - Added Functions for Amicable Number  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/ntheory/factor_.py] (definition of is_amicable:) def is_amicable(m, n): """Returns True if the numbers `m` and `n` are "amicable", else False. Amicable numbers are two different numbers so related that the sum of the proper divisors of each is equal to that of the other. Examples ======== >>> from sympy.ntheory.factor_ import is_amicable, divisor_sigma >>> is_amicable(220, 284) True >>> divisor_sigma(220) == divisor_sigma(284) True References ========== .. [1] https://en.wikipedia.org/wiki/Amicable_numbers""" [end of new definitions in sympy/ntheory/factor_.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

e941ad69638189ea42507331e417b88837357dec

sympy__sympy-16136

16,136

sympy/sympy

1.4

b786c995a59a7bb0e673e80ccb4ccece4dfbcaad

2019-03-02T13:00:06Z

diff --git a/sympy/utilities/__init__.py b/sympy/utilities/__init__.py index 4a5f8d59608f..96bb668185b6 100644 --- a/sympy/utilities/__init__.py +++ b/sympy/utilities/__init__.py @@ -5,7 +5,8 @@ variations, numbered_symbols, cartes, capture, dict_merge, postorder_traversal, interactive_traversal, prefixes, postfixes, sift, topological_sort, unflatten, - has_dups, has_variety, reshape, default_sort_key, ordered) + has_dups, has_variety, reshape, default_sort_key, ordered, + rotations) from .misc import filldedent diff --git a/sympy/utilities/iterables.py b/sympy/utilities/iterables.py index 935bef529bc3..a03d97fa6124 100644 --- a/sympy/utilities/iterables.py +++ b/sympy/utilities/iterables.py @@ -2340,3 +2340,23 @@ def signed_permutations(t): """ return (type(t)(i) for j in permutations(t) for i in permute_signs(j)) + + +def rotations(s, dir=1): + """Return a generator giving the items in s as list where + each subsequent list has the items rotated to the left (default) + or right (dir=-1) relative to the previous list. + + Examples + ======== + + >>> from sympy.utilities.iterables import rotations + >>> list(rotations([1,2,3])) + [[1, 2, 3], [2, 3, 1], [3, 1, 2]] + >>> list(rotations([1,2,3], -1)) + [[1, 2, 3], [3, 1, 2], [2, 3, 1]] + """ + seq = list(s) + for i in range(len(seq)): + yield seq + seq = rotate_left(seq, dir)

diff --git a/sympy/utilities/tests/test_iterables.py b/sympy/utilities/tests/test_iterables.py index 9998af33e1b0..2fb1f5692f6a 100644 --- a/sympy/utilities/tests/test_iterables.py +++ b/sympy/utilities/tests/test_iterables.py @@ -15,7 +15,7 @@ multiset_permutations, necklaces, numbered_symbols, ordered, partitions, permutations, postfixes, postorder_traversal, prefixes, reshape, rotate_left, rotate_right, runs, sift, subsets, take, topological_sort, - unflatten, uniq, variations, ordered_partitions) + unflatten, uniq, variations, ordered_partitions, rotations) from sympy.utilities.enumerative import ( factoring_visitor, multiset_partitions_taocp ) @@ -732,3 +732,9 @@ def test_ordered_partitions(): sum(1 for p in f(i, j, 1)) == sum(1 for p in f(i, j, 0)) == nT(i, j)) + + +def test_rotations(): + assert list(rotations('ab')) == [['a', 'b'], ['b', 'a']] + assert list(rotations(range(3))) == [[0, 1, 2], [1, 2, 0], [2, 0, 1]] + assert list(rotations(range(3), dir=-1)) == [[0, 1, 2], [2, 0, 1], [1, 2, 0]]

[ { "components": [ { "doc": "Return a generator giving the items in s as list where\neach subsequent list has the items rotated to the left (default)\nor right (dir=-1) relative to the previous list.\n\nExamples\n========\n\n>>> from sympy.utilities.iterables import rotations\n>>> list(rotations([1...

[ "test_postorder_traversal", "test_flatten", "test_group", "test_subsets", "test_variations", "test_cartes", "test_filter_symbols", "test_numbered_symbols", "test_sift", "test_take", "test_dict_merge", "test_prefixes", "test_postfixes", "test_topological_sort", "test_rotate", "test_mult...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Function for rotation in iterables  #### References to other Issues or PRs Fixes #16127  #### Brief description of what is fixed or changed Function yielding sequence rotations has been added to iterables.py of the utilities module. #### Other comments #### Release Notes   * utilities * `rotations` function added to iterables.py  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/utilities/iterables.py] (definition of rotations:) def rotations(s, dir=1): """Return a generator giving the items in s as list where each subsequent list has the items rotated to the left (default) or right (dir=-1) relative to the previous list. Examples ======== >>> from sympy.utilities.iterables import rotations >>> list(rotations([1,2,3])) [[1, 2, 3], [2, 3, 1], [3, 1, 2]] >>> list(rotations([1,2,3], -1)) [[1, 2, 3], [3, 1, 2], [2, 3, 1]]""" [end of new definitions in sympy/utilities/iterables.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> iterables could use rotations Would a simple routine to return the rotations of a sequence be something useful in iterables? ```python def rotations(s, dir=1): """Return a generator giving the items in s as list where each subsequent list has the items rotated to the left (default) or right (dir=-1) relative to the previous list. Examples ======== >>> list(rotations([1,2,3])) [[1, 2, 3], [2, 3, 1], [3, 1, 2]] >>> list(rotations([1,2,3], -1)) [[1, 2, 3], [3, 1, 2], [2, 3, 1]] """ seq = list(s) for i in range(len(seq)): yield seq seq = rotate_left(seq, dir) ``` ---------- -------------------- </issues>

e941ad69638189ea42507331e417b88837357dec

sympy__sympy-16109

16,109

sympy/sympy

1.4

a302bbeb5fa4418be4ad82b6b5b3607de3f2d65d

2019-02-28T20:05:57Z

diff --git a/sympy/ntheory/__init__.py b/sympy/ntheory/__init__.py index bf0065221703..6d7ca7de9a2a 100644 --- a/sympy/ntheory/__init__.py +++ b/sympy/ntheory/__init__.py @@ -8,7 +8,8 @@ from .factor_ import divisors, factorint, multiplicity, perfect_power, \ pollard_pm1, pollard_rho, primefactors, totient, trailing, divisor_count, \ divisor_sigma, factorrat, reduced_totient, primenu, primeomega, \ - mersenne_prime_exponent, is_perfect, is_mersenne_prime + mersenne_prime_exponent, is_perfect, is_mersenne_prime, is_abundant, \ + is_deficient, abundance from .partitions_ import npartitions from .residue_ntheory import is_primitive_root, is_quad_residue, \ legendre_symbol, jacobi_symbol, n_order, sqrt_mod, quadratic_residues, \ diff --git a/sympy/ntheory/factor_.py b/sympy/ntheory/factor_.py index ac3c62983615..19f3d90985c4 100644 --- a/sympy/ntheory/factor_.py +++ b/sympy/ntheory/factor_.py @@ -2129,3 +2129,75 @@ def is_mersenne_prime(n): r, b = integer_log(n + 1, 2) return b and r in MERSENNE_PRIME_EXPONENTS + + +def abundance(n): + """Returns the difference between the sum of the positive + proper divisors of a number and the number. + + Examples + ======== + + >>> from sympy.ntheory import abundance, is_perfect, is_abundant + >>> abundance(6) + 0 + >>> is_perfect(6) + True + >>> abundance(10) + -2 + >>> is_abundant(10) + False + """ + return divisor_sigma(n, 1) - 2 * n + + +def is_abundant(n): + """Returns True if ``n`` is an abundant number, else False. + + A abundant number is smaller than the sum of its positive proper divisors. + + Examples + ======== + + >>> from sympy.ntheory.factor_ import is_abundant + >>> is_abundant(20) + True + >>> is_abundant(15) + False + + References + ========== + + .. [1] http://mathworld.wolfram.com/AbundantNumber.html + + """ + n = as_int(n) + if is_perfect(n): + return False + return n % 6 == 0 or bool(abundance(n) > 0) + + +def is_deficient(n): + """Returns True if ``n`` is a deficient number, else False. + + A deficient number is greater than the sum of its positive proper divisors. + + Examples + ======== + + >>> from sympy.ntheory.factor_ import is_deficient + >>> is_deficient(20) + False + >>> is_deficient(15) + True + + References + ========== + + .. [1] http://mathworld.wolfram.com/DeficientNumber.html + + """ + n = as_int(n) + if is_perfect(n): + return False + return bool(abundance(n) < 0)

diff --git a/sympy/ntheory/tests/test_factor_.py b/sympy/ntheory/tests/test_factor_.py index 6226323e26ac..55e6d207cb89 100644 --- a/sympy/ntheory/tests/test_factor_.py +++ b/sympy/ntheory/tests/test_factor_.py @@ -13,7 +13,8 @@ factorrat, reduced_totient) from sympy.ntheory.factor_ import (smoothness, smoothness_p, antidivisors, antidivisor_count, core, digits, udivisors, udivisor_sigma, - udivisor_count, primenu, primeomega, small_trailing, mersenne_prime_exponent, is_perfect, is_mersenne_prime) + udivisor_count, primenu, primeomega, small_trailing, mersenne_prime_exponent, + is_perfect, is_mersenne_prime, is_abundant, is_deficient) from sympy.ntheory.generate import cycle_length from sympy.ntheory.multinomial import ( multinomial_coefficients, multinomial_coefficients_iterator) @@ -589,3 +590,19 @@ def test_is_mersenne_prime(): assert is_mersenne_prime(511) is False assert is_mersenne_prime(131071) is True assert is_mersenne_prime(2147483647) is True + + +def test_is_abundant(): + assert is_abundant(10) is False + assert is_abundant(12) is True + assert is_abundant(18) is True + assert is_abundant(21) is False + assert is_abundant(945) is True + + +def test_is_deficient(): + assert is_deficient(10) is True + assert is_deficient(22) is True + assert is_deficient(56) is False + assert is_deficient(20) is False + assert is_deficient(36) is False

[ { "components": [ { "doc": "Returns the difference between the sum of the positive\nproper divisors of a number and the number.\n\nExamples\n========\n\n>>> from sympy.ntheory import abundance, is_perfect, is_abundant\n>>> abundance(6)\n0\n>>> is_perfect(6)\nTrue\n>>> abundance(10)\n-2\n>>> is_abu...

[ "test_trailing_bitcount", "test_multiplicity", "test_perfect_power", "test_factorint", "test_divisors_and_divisor_count", "test_udivisors_and_udivisor_count", "test_issue_6981", "test_totient", "test_reduced_totient", "test_divisor_sigma", "test_udivisor_sigma", "test_issue_4356", "test_divi...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added is_abundant and is_deficient with test cases  #### References to other Issues or PRs  Fixes #15926 closes #16112 as an alternative Function for perfect number has already been merged on PR #16101 #### Brief description of what is fixed or changed Added functions for abundant and deficient numbers and a function to compute the abundance of a number. #### Other comments #### Release Notes   - ntheory - actor_: added funtions `abundance`, `is_abundant` and `is_deficient`  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/ntheory/factor_.py] (definition of abundance:) def abundance(n): """Returns the difference between the sum of the positive proper divisors of a number and the number. Examples ======== >>> from sympy.ntheory import abundance, is_perfect, is_abundant >>> abundance(6) 0 >>> is_perfect(6) True >>> abundance(10) -2 >>> is_abundant(10) False""" (definition of is_abundant:) def is_abundant(n): """Returns True if ``n`` is an abundant number, else False. A abundant number is smaller than the sum of its positive proper divisors. Examples ======== >>> from sympy.ntheory.factor_ import is_abundant >>> is_abundant(20) True >>> is_abundant(15) False References ========== .. [1] http://mathworld.wolfram.com/AbundantNumber.html""" (definition of is_deficient:) def is_deficient(n): """Returns True if ``n`` is a deficient number, else False. A deficient number is greater than the sum of its positive proper divisors. Examples ======== >>> from sympy.ntheory.factor_ import is_deficient >>> is_deficient(20) False >>> is_deficient(15) True References ========== .. [1] http://mathworld.wolfram.com/DeficientNumber.html""" [end of new definitions in sympy/ntheory/factor_.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Function for perfect, deficient, abundant numbers There should be a separate function for checking whether a number is perfect, deficient or abundant. If you liked this idea then I can add a pull request. - [x] perfect - [x] deficient - [x] abundant ---------- I think it would be good to have. For perfect numbers, there are only [51 known ones](https://en.wikipedia.org/wiki/Mersenne_prime), so we could just check against a list. I don't know if there is an efficient way to test if a number is abundant. I think ntheory/factor_.py would be the appropriate place @asmeurer I can think of the following heuristics for this. 1. All primes and its powers are deficient. 2. Every multiple of abundant and perfect number is abundant. This will need some changes. Please suggest. I have checked outputs. It takes some time to calculate 40th Perfect Numbers to 51th Perfect Numbers. but We can show it with symbol. I also have test cases for Perfect Numbers. I can add them if you want to. I have not added comments yet. Comments can also be added. I'm working on deficient and will try to cover abundant as well. --------------------Function addition for deficient numbers  #### References to other Issues or PRs Fixes #15926  #### Brief description of what is fixed or changed A function is implemented for `deficient numbers `in `number theory`. #### Other comments #### Release Notes   * ntheory * Addition of function deficient in factor_.py  ---------- -------------------- </issues>

e941ad69638189ea42507331e417b88837357dec

scikit-learn__scikit-learn-13336

13,336

scikit-learn/scikit-learn

0.21

984871b89baa183b1d0e284ac9bb22de06a59e8d

2019-02-28T15:54:52Z

diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 6f504a721ec75..e3e3ec9f88816 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -230,6 +230,10 @@ Support for Python 3.4 and below has been officially dropped. in version 0.21 and will be removed in version 0.23. :issue:`12821` by :user:`Nicolas Hug <NicolasHug>`. +- |Enhancement| `sparse_cg` solver in :class:`linear_model.ridge.Ridge` + now supports fitting the intercept (i.e. ``fit_intercept=True``) when + inputs are sparse . :issue:`13336` by :user:`Bartosz Telenczuk <btel>` + :mod:`sklearn.manifold` ............................ diff --git a/sklearn/linear_model/ridge.py b/sklearn/linear_model/ridge.py index eed636622dcdc..e240db3f1cb06 100644 --- a/sklearn/linear_model/ridge.py +++ b/sklearn/linear_model/ridge.py @@ -33,9 +33,31 @@ from ..exceptions import ConvergenceWarning -def _solve_sparse_cg(X, y, alpha, max_iter=None, tol=1e-3, verbose=0): +def _solve_sparse_cg(X, y, alpha, max_iter=None, tol=1e-3, verbose=0, + X_offset=None, X_scale=None): + + def _get_rescaled_operator(X): + + X_offset_scale = X_offset / X_scale + + def matvec(b): + return X.dot(b) - b.dot(X_offset_scale) + + def rmatvec(b): + return X.T.dot(b) - X_offset_scale * np.sum(b) + + X1 = sparse.linalg.LinearOperator(shape=X.shape, + matvec=matvec, + rmatvec=rmatvec) + return X1 + n_samples, n_features = X.shape - X1 = sp_linalg.aslinearoperator(X) + + if X_offset is None or X_scale is None: + X1 = sp_linalg.aslinearoperator(X) + else: + X1 = _get_rescaled_operator(X) + coefs = np.empty((y.shape[1], n_features), dtype=X.dtype) if n_features > n_samples: @@ -326,6 +348,25 @@ def ridge_regression(X, y, alpha, sample_weight=None, solver='auto', ----- This function won't compute the intercept. """ + + return _ridge_regression(X, y, alpha, + sample_weight=sample_weight, + solver=solver, + max_iter=max_iter, + tol=tol, + verbose=verbose, + random_state=random_state, + return_n_iter=return_n_iter, + return_intercept=return_intercept, + X_scale=None, + X_offset=None) + + +def _ridge_regression(X, y, alpha, sample_weight=None, solver='auto', + max_iter=None, tol=1e-3, verbose=0, random_state=None, + return_n_iter=False, return_intercept=False, + X_scale=None, X_offset=None): + if return_intercept and sparse.issparse(X) and solver != 'sag': if solver != 'auto': warnings.warn("In Ridge, only 'sag' solver can currently fit the " @@ -395,7 +436,12 @@ def ridge_regression(X, y, alpha, sample_weight=None, solver='auto', n_iter = None if solver == 'sparse_cg': - coef = _solve_sparse_cg(X, y, alpha, max_iter, tol, verbose) + coef = _solve_sparse_cg(X, y, alpha, + max_iter=max_iter, + tol=tol, + verbose=verbose, + X_offset=X_offset, + X_scale=X_scale) elif solver == 'lsqr': coef, n_iter = _solve_lsqr(X, y, alpha, max_iter, tol) @@ -492,24 +538,35 @@ def fit(self, X, y, sample_weight=None): np.atleast_1d(sample_weight).ndim > 1): raise ValueError("Sample weights must be 1D array or scalar") + # when X is sparse we only remove offset from y X, y, X_offset, y_offset, X_scale = self._preprocess_data( X, y, self.fit_intercept, self.normalize, self.copy_X, - sample_weight=sample_weight) + sample_weight=sample_weight, return_mean=True) # temporary fix for fitting the intercept with sparse data using 'sag' - if sparse.issparse(X) and self.fit_intercept: - self.coef_, self.n_iter_, self.intercept_ = ridge_regression( + if (sparse.issparse(X) and self.fit_intercept and + self.solver != 'sparse_cg'): + self.coef_, self.n_iter_, self.intercept_ = _ridge_regression( X, y, alpha=self.alpha, sample_weight=sample_weight, max_iter=self.max_iter, tol=self.tol, solver=self.solver, random_state=self.random_state, return_n_iter=True, return_intercept=True) + # add the offset which was subtracted by _preprocess_data self.intercept_ += y_offset else: - self.coef_, self.n_iter_ = ridge_regression( + if sparse.issparse(X): + # required to fit intercept with sparse_cg solver + params = {'X_offset': X_offset, 'X_scale': X_scale} + else: + # for dense matrices or when intercept is set to 0 + params = {} + + self.coef_, self.n_iter_ = _ridge_regression( X, y, alpha=self.alpha, sample_weight=sample_weight, max_iter=self.max_iter, tol=self.tol, solver=self.solver, random_state=self.random_state, return_n_iter=True, - return_intercept=False) + return_intercept=False, **params) + self._set_intercept(X_offset, y_offset, X_scale) return self

diff --git a/sklearn/linear_model/tests/test_ridge.py b/sklearn/linear_model/tests/test_ridge.py index eca4a53f4f507..a5ee524e8c557 100644 --- a/sklearn/linear_model/tests/test_ridge.py +++ b/sklearn/linear_model/tests/test_ridge.py @@ -815,21 +815,25 @@ def test_n_iter(): def test_ridge_fit_intercept_sparse(): X, y = make_regression(n_samples=1000, n_features=2, n_informative=2, bias=10., random_state=42) + X_csr = sp.csr_matrix(X) - for solver in ['saga', 'sag']: + for solver in ['sag', 'sparse_cg']: dense = Ridge(alpha=1., tol=1.e-15, solver=solver, fit_intercept=True) sparse = Ridge(alpha=1., tol=1.e-15, solver=solver, fit_intercept=True) dense.fit(X, y) - sparse.fit(X_csr, y) + with pytest.warns(None) as record: + sparse.fit(X_csr, y) + assert len(record) == 0 assert_almost_equal(dense.intercept_, sparse.intercept_) assert_array_almost_equal(dense.coef_, sparse.coef_) # test the solver switch and the corresponding warning - sparse = Ridge(alpha=1., tol=1.e-15, solver='lsqr', fit_intercept=True) - assert_warns(UserWarning, sparse.fit, X_csr, y) - assert_almost_equal(dense.intercept_, sparse.intercept_) - assert_array_almost_equal(dense.coef_, sparse.coef_) + for solver in ['saga', 'lsqr']: + sparse = Ridge(alpha=1., tol=1.e-15, solver=solver, fit_intercept=True) + assert_warns(UserWarning, sparse.fit, X_csr, y) + assert_almost_equal(dense.intercept_, sparse.intercept_) + assert_array_almost_equal(dense.coef_, sparse.coef_) def test_errors_and_values_helper():

diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 6f504a721ec75..e3e3ec9f88816 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -230,6 +230,10 @@ Support for Python 3.4 and below has been officially dropped. in version 0.21 and will be removed in version 0.23. :issue:`12821` by :user:`Nicolas Hug <NicolasHug>`. +- |Enhancement| `sparse_cg` solver in :class:`linear_model.ridge.Ridge` + now supports fitting the intercept (i.e. ``fit_intercept=True``) when + inputs are sparse . :issue:`13336` by :user:`Bartosz Telenczuk <btel>` + :mod:`sklearn.manifold` ............................

[ { "components": [ { "doc": "", "lines": [ 39, 52 ], "name": "_solve_sparse_cg._get_rescaled_operator", "signature": "def _get_rescaled_operator(X):", "type": "function" }, { "doc": "", "lines": [ 43, ...

[ "sklearn/linear_model/tests/test_ridge.py::test_ridge_fit_intercept_sparse" ]

[ "sklearn/linear_model/tests/test_ridge.py::test_ridge[svd]", "sklearn/linear_model/tests/test_ridge.py::test_ridge[sparse_cg]", "sklearn/linear_model/tests/test_ridge.py::test_ridge[cholesky]", "sklearn/linear_model/tests/test_ridge.py::test_ridge[lsqr]", "sklearn/linear_model/tests/test_ridge.py::test_ridg...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG] Implement fitting intercept with `sparse_cg` solver in Ridge regression  #### Reference Issues/PRs  See also #470 It follows the same trick as introduced in PR #13279 by @agramfort #### What does this implement/fix? Explain your changes. This implements fitting intercept with `sparse_cg` solver in Ridge regression (i.e. when `fit_intercept==True`) for sparse inputs. It also means that both sparse and dense cases give the same result. #### Any other comments? **Important**: This PR changes the auto-selected solver (`solver='auto'`) from `sag` to `sparse_cg` when `fit_intercept==True` and input is sparse. There are still problems with the code: 1) 'auto' mode in ridge_regression function may trigger wrong solvers (for example, when inputs is sparse and sample_weight is passed) 2) Warning message about changing the solver is not fully informative/correct. For example, user might choose the `sparse_cg` solver instead of going the `sag` way. 3) The estimator object is not informed about the fact that the solver was changed (or which solver was selected by `auto`) They are not related to this PR and will be fixed in another PR.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/linear_model/ridge.py] (definition of _solve_sparse_cg._get_rescaled_operator:) def _get_rescaled_operator(X): (definition of _solve_sparse_cg._get_rescaled_operator.matvec:) def matvec(b): (definition of _solve_sparse_cg._get_rescaled_operator.rmatvec:) def rmatvec(b): (definition of _ridge_regression:) def _ridge_regression(X, y, alpha, sample_weight=None, solver='auto', max_iter=None, tol=1e-3, verbose=0, random_state=None, return_n_iter=False, return_intercept=False, X_scale=None, X_offset=None): [end of new definitions in sklearn/linear_model/ridge.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

66cc1c7342f7f0cc0dc57fb6d56053fc46c8e5f0

sympy__sympy-16101

16,101

sympy/sympy

1.4

f4b483507a6704f2f431494413c54766f3d77d3e

2019-02-27T23:44:13Z

diff --git a/sympy/ntheory/__init__.py b/sympy/ntheory/__init__.py index 31977979af8f..bf0065221703 100644 --- a/sympy/ntheory/__init__.py +++ b/sympy/ntheory/__init__.py @@ -7,7 +7,8 @@ from .primetest import isprime from .factor_ import divisors, factorint, multiplicity, perfect_power, \ pollard_pm1, pollard_rho, primefactors, totient, trailing, divisor_count, \ - divisor_sigma, factorrat, reduced_totient, primenu, primeomega + divisor_sigma, factorrat, reduced_totient, primenu, primeomega, \ + mersenne_prime_exponent, is_perfect, is_mersenne_prime from .partitions_ import npartitions from .residue_ntheory import is_primitive_root, is_quad_residue, \ legendre_symbol, jacobi_symbol, n_order, sqrt_mod, quadratic_residues, \ diff --git a/sympy/ntheory/factor_.py b/sympy/ntheory/factor_.py index 2d3362822a7c..ac3c62983615 100644 --- a/sympy/ntheory/factor_.py +++ b/sympy/ntheory/factor_.py @@ -19,6 +19,14 @@ from .primetest import isprime from .generate import sieve, primerange, nextprime + +# Note: This list should be updated whenever new Mersenne primes are found. +# Refer: https://www.mersenne.org/ +MERSENNE_PRIME_EXPONENTS = (2, 3, 5, 7, 13, 17, 19, 31, 61, 89, 107, 127, 521, 607, 1279, 2203, + 2281, 3217, 4253, 4423, 9689, 9941, 11213, 19937, 21701, 23209, 44497, 86243, 110503, 132049, + 216091, 756839, 859433, 1257787, 1398269, 2976221, 3021377, 6972593, 13466917, 20996011, 24036583, + 25964951, 30402457, 32582657, 37156667, 42643801, 43112609, 57885161, 74207281, 77232917, 82589933) + small_trailing = [0] * 256 for j in range(1,8): small_trailing[1<<j::1<<(j+1)] = [j] * (1<<(7-j)) @@ -2040,3 +2048,84 @@ def eval(cls, n): raise ValueError("n must be a positive integer") else: return sum(factorint(n).values()) + + +def mersenne_prime_exponent(nth): + """Returns the exponent ``i`` for the nth Mersenne prime (which + has the form `2^i - 1`). + + Examples + ======== + + >>> from sympy.ntheory.factor_ import mersenne_prime_exponent + >>> mersenne_prime_exponent(1) + 2 + >>> mersenne_prime_exponent(20) + 4423 + """ + n = as_int(nth) + if n < 1: + raise ValueError("nth must be a positive integer; mersenne_prime_exponent(1) == 2") + if n > 51: + raise ValueError("There are only 51 perfect numbers; nth must be less than or equal to 51") + return MERSENNE_PRIME_EXPONENTS[n - 1] + + +def is_perfect(n): + """Returns True if ``n`` is a perfect number, else False. + + A perfect number is equal to the sum of its positive, proper divisors. + + Examples + ======== + + >>> from sympy.ntheory.factor_ import is_perfect, divisors + >>> is_perfect(20) + False + >>> is_perfect(6) + True + >>> sum(divisors(6)[:-1]) + 6 + + References + ========== + + .. [1] http://mathworld.wolfram.com/PerfectNumber.html + + """ + from sympy.core.power import integer_log + + r, b = integer_nthroot(1 + 8*n, 2) + if not b: + return False + n, x = divmod(1 + r, 4) + if x: + return False + e, b = integer_log(n, 2) + return b and (e + 1) in MERSENNE_PRIME_EXPONENTS + + +def is_mersenne_prime(n): + """Returns True if ``n`` is a Mersenne prime, else False. + + A Mersenne prime is a prime number having the form `2^i - 1`. + + Examples + ======== + + >>> from sympy.ntheory.factor_ import is_mersenne_prime + >>> is_mersenne_prime(6) + False + >>> is_mersenne_prime(127) + True + + References + ========== + + .. [1] http://mathworld.wolfram.com/MersennePrime.html + + """ + from sympy.core.power import integer_log + + r, b = integer_log(n + 1, 2) + return b and r in MERSENNE_PRIME_EXPONENTS

diff --git a/sympy/ntheory/tests/test_factor_.py b/sympy/ntheory/tests/test_factor_.py index 2bcb8b5e62d9..6226323e26ac 100644 --- a/sympy/ntheory/tests/test_factor_.py +++ b/sympy/ntheory/tests/test_factor_.py @@ -13,7 +13,7 @@ factorrat, reduced_totient) from sympy.ntheory.factor_ import (smoothness, smoothness_p, antidivisors, antidivisor_count, core, digits, udivisors, udivisor_sigma, - udivisor_count, primenu, primeomega, small_trailing) + udivisor_count, primenu, primeomega, small_trailing, mersenne_prime_exponent, is_perfect, is_mersenne_prime) from sympy.ntheory.generate import cycle_length from sympy.ntheory.multinomial import ( multinomial_coefficients, multinomial_coefficients_iterator) @@ -562,3 +562,30 @@ def test_primeomega(): assert primeomega(n) assert primeomega(n).subs(n, 2 ** 31 - 1) == 1 assert summation(primeomega(n), (n, 2, 30)) == 59 + + +def test_mersenne_prime_exponent(): + assert mersenne_prime_exponent(1) == 2 + assert mersenne_prime_exponent(4) == 7 + assert mersenne_prime_exponent(10) == 89 + assert mersenne_prime_exponent(25) == 21701 + raises(ValueError, lambda: mersenne_prime_exponent(52)) + raises(ValueError, lambda: mersenne_prime_exponent(0)) + + +def test_is_perfect(): + assert is_perfect(6) is True + assert is_perfect(15) is False + assert is_perfect(28) is True + assert is_perfect(400) is False + assert is_perfect(496) is True + assert is_perfect(8128) is True + assert is_perfect(10000) is False + + +def test_is_mersenne_prime(): + assert is_mersenne_prime(10) is False + assert is_mersenne_prime(127) is True + assert is_mersenne_prime(511) is False + assert is_mersenne_prime(131071) is True + assert is_mersenne_prime(2147483647) is True

[ { "components": [ { "doc": "Returns the exponent ``i`` for the nth Mersenne prime (which\nhas the form `2^i - 1`).\n\nExamples\n========\n\n>>> from sympy.ntheory.factor_ import mersenne_prime_exponent\n>>> mersenne_prime_exponent(1)\n2\n>>> mersenne_prime_exponent(20)\n4423", "lines": [ ...

[ "test_trailing_bitcount", "test_multiplicity", "test_perfect_power", "test_factorint", "test_divisors_and_divisor_count", "test_udivisors_and_udivisor_count", "test_issue_6981", "test_totient", "test_reduced_totient", "test_divisor_sigma", "test_udivisor_sigma", "test_issue_4356", "test_divi...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Functions for Perfect Number  #### References to other Issues or PRs  part of #15926 #### Brief description of what is fixed or changed Added mersenne_prime_exponent ,is_perfect and is_mersenne_prime #### Other comments Already been reviewed at #16055 #### Release Notes   - ntheory - added ischeck functions for both perfect number and mersenne prime using list of mersenne prime exponents.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/ntheory/factor_.py] (definition of mersenne_prime_exponent:) def mersenne_prime_exponent(nth): """Returns the exponent ``i`` for the nth Mersenne prime (which has the form `2^i - 1`). Examples ======== >>> from sympy.ntheory.factor_ import mersenne_prime_exponent >>> mersenne_prime_exponent(1) 2 >>> mersenne_prime_exponent(20) 4423""" (definition of is_perfect:) def is_perfect(n): """Returns True if ``n`` is a perfect number, else False. A perfect number is equal to the sum of its positive, proper divisors. Examples ======== >>> from sympy.ntheory.factor_ import is_perfect, divisors >>> is_perfect(20) False >>> is_perfect(6) True >>> sum(divisors(6)[:-1]) 6 References ========== .. [1] http://mathworld.wolfram.com/PerfectNumber.html""" (definition of is_mersenne_prime:) def is_mersenne_prime(n): """Returns True if ``n`` is a Mersenne prime, else False. A Mersenne prime is a prime number having the form `2^i - 1`. Examples ======== >>> from sympy.ntheory.factor_ import is_mersenne_prime >>> is_mersenne_prime(6) False >>> is_mersenne_prime(127) True References ========== .. [1] http://mathworld.wolfram.com/MersennePrime.html""" [end of new definitions in sympy/ntheory/factor_.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

e941ad69638189ea42507331e417b88837357dec

falconry__falcon-1459

1,459

falconry/falcon

null

4fd9de5c8a3f8a71f59b375bb374082312e673e8

2019-02-24T01:46:19Z

diff --git a/falcon/request.py b/falcon/request.py index 669bdd7cc..4ddcf54b8 100644 --- a/falcon/request.py +++ b/falcon/request.py @@ -355,32 +355,24 @@ class Request(object): range_unit (str): Unit of the range parsed from the value of the Range header, or ``None`` if the header is missing if_match (list): Value of the If-Match header, as a parsed list of - :class:`falcon.ETag` objects or ``None`` if the header is missing. + :class:`falcon.ETag` objects or ``None`` if the header is missing + or its value is blank. - This property is determined by the value of ``HTTP_IF_MATCH`` - in the WSGI environment dict. + This property provides a list of all ``entity-tags`` in the + header, both strong and weak, in the same order as listed in + the header. - Note: - This property includes strong and weak entity-tags. Per - `RFC 7239`_, two entity-tags are equivalent if both are not - weak and their opaque-tags match character-by-character. - - (See also: RFC 7239, Section 3.1) + (See also: RFC 7232, Section 3.1) if_none_match (list): Value of the If-None-Match header, as a parsed list of :class:`falcon.ETag` objects or ``None`` if the header is - missing. + missing or its value is blank. - This property is determined by the value of ``HTTP_IF_NONE_MATCH`` - in the WSGI environment dict. - - Note: - This property includes strong and weak entity-tags. Per - `RFC 7239`_, two entity-tags are equivalent if their - opaque-tags match character-by-character, regardless of - either or both being tagged as weak. + This property provides a list of all ``entity-tags`` in the + header, both strong and weak, in the same order as listed in + the header. - (See also: RFC 7239, Section 3.2) + (See also: RFC 7232, Section 3.2) if_modified_since (datetime): Value of the If-Modified-Since header, or ``None`` if the header is missing. @@ -433,6 +425,8 @@ class Request(object): _cookies = None _cookies_collapsed = None + _cached_if_match = None + _cached_if_none_match = None # Child classes may override this context_type = type('RequestContext', (dict,), {}) @@ -619,11 +613,30 @@ def date(self): @property def if_match(self): - return helpers.parse_etags(self.env.get('HTTP_IF_MATCH')) + # TODO(kgriffs): It may make sense at some point to create a + # header property generator that DRY's up the memoization + # pattern for us. + # PERF(kgriffs): It probably isn't worth it to set + # self._cached_if_match to a special type/object to distinguish + # between the variable being unset and the header not being + # present in the request. The reason is that if the app + # gets a None back on the first reference to property, it + # probably isn't going to access the property again (TBD). + if self._cached_if_match is None: + header_value = self.env.get('HTTP_IF_MATCH') + if header_value: + self._cached_if_match = helpers._parse_etags(header_value) + + return self._cached_if_match @property def if_none_match(self): - return helpers.parse_etags(self.env.get('HTTP_IF_NONE_MATCH')) + if self._cached_if_none_match is None: + header_value = self.env.get('HTTP_IF_NONE_MATCH') + if header_value: + self._cached_if_none_match = helpers._parse_etags(header_value) + + return self._cached_if_none_match @property def if_modified_since(self): diff --git a/falcon/request_helpers.py b/falcon/request_helpers.py index db7ca02ef..276939041 100644 --- a/falcon/request_helpers.py +++ b/falcon/request_helpers.py @@ -28,7 +28,12 @@ # _COOKIE_NAME_RESERVED_CHARS = re.compile('[\x00-\x1F\x7F-\xFF()<>@,;:\\\\"/[\\]?={} \x09]') -_ETAG_PATTERN = re.compile(r'([Ww]/)?(?:"(.*?)"|(.*?))(?:\s*,\s*|$)') +# NOTE(kgriffs): strictly speaking, the weakness indicator is +# case-sensitive, but this wasn't explicit until RFC 7232 +# so we allow for both. We also require quotes because that's +# been standardized since 1999, and it makes the regex simpler +# and more performant. +_ENTITY_TAG_PATTERN = re.compile(r'([Ww]/)?"([^"]*)"') def parse_cookie_header(header_value): @@ -113,26 +118,18 @@ def fget(self): return property(fget) -def make_etag(value, is_weak=False): - """Creates and returns a ETag object. +# NOTE(kgriffs): Going forward we should privatize helpers, as done here. We +# can always move this over to falcon.util if we decide it would be +# more generally useful to app developers. +def _parse_etags(etag_str): + """Parse a string containing one or more HTTP entity-tags. - Args: - value (str): Unquated entity tag value - is_weak (bool): The weakness indicator - - Returns: - A ``str``-like Etag instance with weakness indicator. + The string is assumed to be formatted as defined for a precondition + header, and may contain either a single ETag, or multiple comma-separated + ETags. The string may also contain a '*' character, in order to indicate + that any ETag should match the precondition. - """ - etag = ETag(value) - etag.is_weak = is_weak - return etag - - -def parse_etags(etag_str): - """ - Parse a string of ETags given in the If-Match or If-None-Match header as - defined by RFC 7232. + (See also: RFC 7232, Section 3) Args: etag_str (str): An ASCII header value to parse ETags from. ETag values @@ -140,42 +137,38 @@ def parse_etags(etag_str): function should be used. Returns: - A list of unquoted ETags or ``['*']`` if all ETags should be matched. + list: A list of unquoted ETags or ``['*']`` if all ETags should be + matched. If the string to be parse is empty, or contains only + whitespace, ``None`` will be returned instead. """ - if etag_str is None: - return None - etags = [] etag_str = etag_str.strip() if not etag_str: - return etags + return None if etag_str == '*': - etags.append(etag_str) - return etags + return [etag_str] if ',' not in etag_str: - value = etag_str - is_weak = False - if value.startswith(('W/', 'w/')): - is_weak = True - value = value[2:] - if value[:1] == value[-1:] == '"': - value = value[1:-1] - etags.append(make_etag(value, is_weak)) - else: - pos = 0 - end = len(etag_str) - while pos < end: - match = _ETAG_PATTERN.match(etag_str, pos) - is_weak, quoted, raw = match.groups() - value = quoted or raw - if value: - etags.append(make_etag(value, bool(is_weak))) - pos = match.end() - - return etags + return [ETag.loads(etag_str)] + + etags = [] + + # PERF(kgriffs): Parsing out the weak string like this turns out to be more + # performant than grabbing the entire entity-tag and passing it to + # ETag.loads(). This is also faster than parsing etag_str manually via + # str.find() and slicing. + for weak, value in _ENTITY_TAG_PATTERN.findall(etag_str): + t = ETag(value) + t.is_weak = bool(weak) + etags.append(t) + + # NOTE(kgriffs): Normalize a string with only whitespace and commas + # to None, since it is like a list of individual ETag headers that + # are all set to nothing, and so therefore basically should be + # treated as not having been set in the first place. + return etags or None class BoundedStream(io.IOBase): diff --git a/falcon/util/structures.py b/falcon/util/structures.py index 26d6e7bce..cba3e77a0 100644 --- a/falcon/util/structures.py +++ b/falcon/util/structures.py @@ -108,22 +108,114 @@ def __repr__(self): class ETag(str): - """An entity-tag ``str``-like object with the weakness indicator. + """Convenience class to represent a parsed HTTP entity-tag. + + This class is simply a subclass of ``str`` with a few helper methods and + an extra attribute to indicate whether the entity-tag is weak or strong. The + value of the string is equivalent to what RFC 7232 calls an "opaque-tag", + i.e. an entity-tag sans quotes and the weakness indicator. + + Note: + + Given that a weak entity-tag comparison can be performed by + using the ``==`` operator (per the example below), only a + :meth:`~.strong_compare` method is provided. + + Here is an example ``on_get()`` method that demonstrates how to use instances + of this class:: + + def on_get(self, req, resp): + content_etag = self._get_content_etag() + for etag in (req.if_none_match or []): + if etag == '*' or etag == content_etag: + resp.status = falcon.HTTP_304 + return + + # ... + + resp.etag = content_etag + resp.status = falcon.HTTP_200 + + (See also: RFC 7232) Attributes: - is_weak (bool): The weakness indicator. + is_weak (bool): ``True`` if the entity-tag is weak, otherwise ``False``. """ + is_weak = False - def to_header(self): - """Convert the ETag into a HTTP header string. + def strong_compare(self, other): + """Performs a strong entity-tag comparison. + + Two entity-tags are equivalent if both are not weak and their + opaque-tags match character-by-character. + + (See also: RFC 7232, Section 2.3.2) + + Arguments: + other (ETag): The other :class:`~.ETag` to which you are comparing + this one. + + Returns: + bool: ``True`` if the two entity-tags match, otherwise ``False``. + + """ + + return self == other and not (self.is_weak or other.is_weak) + + def dumps(self): + """Serialize the ETag to a string suitable for use in a precondition header. + + (See also: RFC 7232, Section 2.3) Returns: str: An opaque quoted string, possibly prefixed by a weakness indicator ``W/``. - """ + if self.is_weak: - return 'W/"%s"' % self - return '"%s"' % self + # PERF(kgriffs): Simple concatenation like this is slightly faster + # than %s string formatting. + return 'W/"' + self + '"' + + return '"' + self + '"' + + @classmethod + def loads(cls, etag_str): + """Class method that deserializes a single entity-tag string from a precondition header. + + Note: + + This method is meant to be used only for parsing a single + entity-tag. It can not be used to parse a comma-separated list of + values. + + (See also: RFC 7232, Section 2.3) + + Arguments: + etag_str (str): An ASCII string representing a single entity-tag, + as defined by RFC 7232. + + Returns: + ETag: An instance of `~.ETag` representing the parsed entity-tag. + + """ + + value = etag_str + + is_weak = False + if value.startswith(('W/', 'w/')): + is_weak = True + value = value[2:] + + # NOTE(kgriffs): We allow for an unquoted entity-tag just in case, + # although it has been non-standard to do so since at least 1999 + # with the advent of RFC 2616. + if value[:1] == value[-1:] == '"': + value = value[1:-1] + + t = cls(value) + t.is_weak = is_weak + + return t

diff --git a/tests/test_request_attrs.py b/tests/test_request_attrs.py index 2e710ff7d..a7f7b639b 100644 --- a/tests/test_request_attrs.py +++ b/tests/test_request_attrs.py @@ -5,14 +5,32 @@ import falcon from falcon.request import Request, RequestOptions -from falcon.request_helpers import make_etag +from falcon.request_helpers import _parse_etags import falcon.testing as testing import falcon.uri from falcon.util import compat +from falcon.util.structures import ETag _PROTOCOLS = ['HTTP/1.0', 'HTTP/1.1'] +def _make_etag(value, is_weak=False): + """Creates and returns an ETag object. + + Args: + value (str): Unquated entity tag value + is_weak (bool): The weakness indicator + + Returns: + A ``str``-like Etag instance with weakness indicator. + + """ + etag = ETag(value) + + etag.is_weak = is_weak + return etag + + class TestRequestAttributes(object): def setup_method(self, method): @@ -785,39 +803,121 @@ def test_app_missing(self): assert req.app == '' @pytest.mark.parametrize('etag,expected', [ - ('', []), - (',', []), + ('', None), + (' ', None), + (' ', None), + ('\t', None), + (' \t', None), + (',', None), + (',,', None), + (',, ', None), + (', , ', None), ('*', ['*']), ( 'W/"67ab43"', - [make_etag('67ab43', is_weak=True)] + [_make_etag('67ab43', is_weak=True)] ), ( 'w/"67ab43"', - [make_etag('67ab43', is_weak=True)] + [_make_etag('67ab43', is_weak=True)] + ), + ( + ' w/"67ab43"', + [_make_etag('67ab43', is_weak=True)] + ), + ( + 'w/"67ab43" ', + [_make_etag('67ab43', is_weak=True)] + ), + ( + 'w/"67ab43 " ', + [_make_etag('67ab43 ', is_weak=True)] ), ( '"67ab43"', - [make_etag('67ab43', is_weak=True)] + [_make_etag('67ab43')] + ), + ( + ' "67ab43"', + [_make_etag('67ab43')] + ), + ( + ' "67ab43" ', + [_make_etag('67ab43')] + ), + ( + '"67ab43" ', + [_make_etag('67ab43')] + ), + ( + '" 67ab43" ', + [_make_etag(' 67ab43')] + ), + ( + '67ab43"', + [_make_etag('67ab43"')] + ), + ( + '"67ab43', + [_make_etag('"67ab43')] ), ( '67ab43', - [make_etag('67ab43', is_weak=False)] + [_make_etag('67ab43')] + ), + ( + '67ab43 ', + [_make_etag('67ab43')] + ), + ( + ' 67ab43 ', + [_make_etag('67ab43')] + ), + ( + ' 67ab43', + [_make_etag('67ab43')] ), ( - 'W/"67ab43", "54ed21", 42we85', - [make_etag('67ab43', is_weak=True), - make_etag('54ed21', is_weak=False), - make_etag('42we85', is_weak=False)] + # NOTE(kgriffs): To simplify parsing and improve performance, we + # do not attempt to handle unquoted entity-tags when there is + # a list; it is non-standard anyway, and has been since 1999. + 'W/"67ab43", "54ed21", junk"F9,22", junk "41, 7F", unquoted, w/"22, 41, 7F", "", W/""', + [ + _make_etag('67ab43', is_weak=True), + _make_etag('54ed21'), + + # NOTE(kgriffs): Test that the ETag initializer defaults to + # is_weak == False + ETag('F9,22'), + + _make_etag('41, 7F'), + _make_etag('22, 41, 7F', is_weak=True), + + # NOTE(kgriffs): According to the grammar in RFC 7232, zero + # etagc's is acceptable. + _make_etag(''), + _make_etag('', is_weak=True), + ] ), ]) def test_etag(self, etag, expected): - self._test_header_expected_value('If-Match', etag, 'if_match', expected) - self._test_header_expected_value('If-None-Match', etag, 'if_none_match', expected) + self._test_header_etag('If-Match', etag, 'if_match', expected) + self._test_header_etag('If-None-Match', etag, 'if_none_match', expected) def test_etag_is_missing(self): - assert self.req.if_match is None - assert self.req.if_none_match is None + # NOTE(kgriffs): Loop in order to test caching + for __ in range(3): + assert self.req.if_match is None + assert self.req.if_none_match is None + + @pytest.mark.parametrize('header_value', ['', ' ', ' ']) + def test_etag_parsing_helper(self, header_value): + # NOTE(kgriffs): Test a couple of cases that are not directly covered + # elsewhere (but that we want the helper to still support + # for the sake of avoiding suprises if they are ever called without + # preflighting the header value). + + assert _parse_etags(header_value) is None # ------------------------------------------------------------------------- # Helpers @@ -836,6 +936,25 @@ def _test_header_expected_value(self, name, value, attr, expected_value): req = Request(testing.create_environ(headers=headers)) assert getattr(req, attr) == expected_value + def _test_header_etag(self, name, value, attr, expected_value): + headers = {name: value} + req = Request(testing.create_environ(headers=headers)) + + # NOTE(kgriffs): Loop in order to test caching + for __ in range(3): + value = getattr(req, attr) + + if expected_value is None: + assert value is None + return + + assert value is not None + + for element, expected_element in zip(value, expected_value): + assert element == expected_element + if isinstance(expected_element, ETag): + assert element.is_weak == expected_element.is_weak + def _test_error_details(self, headers, attr_name, error_type, title, description): req = Request(testing.create_environ(headers=headers)) diff --git a/tests/test_utils.py b/tests/test_utils.py index 4890e35cf..2626a2cd6 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -332,11 +332,47 @@ def test_get_http_status(self): falcon.get_http_status('-404.3') assert falcon.get_http_status(123, 'Go Away') == '123 Go Away' - def test_etag_to_header(self): + def test_etag_dumps_to_header_format(self): etag = structures.ETag('67ab43') - assert etag.to_header() == '"67ab43"' + + assert etag.dumps() == '"67ab43"' + etag.is_weak = True - assert etag.to_header() == 'W/"67ab43"' + assert etag.dumps() == 'W/"67ab43"' + + assert structures.ETag('67a b43').dumps() == '"67a b43"' + + def test_etag_strong_vs_weak_comparison(self): + strong_67ab43_one = structures.ETag.loads('"67ab43"') + strong_67ab43_too = structures.ETag.loads('"67ab43"') + strong_67aB43 = structures.ETag.loads('"67aB43"') + weak_67ab43_one = structures.ETag.loads('W/"67ab43"') + weak_67ab43_two = structures.ETag.loads('W/"67ab43"') + weak_67aB43 = structures.ETag.loads('W/"67aB43"') + + assert strong_67aB43 == strong_67aB43 + assert weak_67aB43 == weak_67aB43 + assert strong_67aB43 == weak_67aB43 + assert weak_67aB43 == strong_67aB43 + assert strong_67ab43_one == strong_67ab43_too + assert weak_67ab43_one == weak_67ab43_two + + assert strong_67aB43 != strong_67ab43_one + assert strong_67ab43_one != strong_67aB43 + + assert strong_67aB43.strong_compare(strong_67aB43) + assert strong_67ab43_one.strong_compare(strong_67ab43_too) + assert not strong_67aB43.strong_compare(strong_67ab43_one) + assert not strong_67ab43_one.strong_compare(strong_67aB43) + + assert not strong_67ab43_one.strong_compare(weak_67ab43_one) + assert not weak_67ab43_one.strong_compare(strong_67ab43_one) + + assert not weak_67aB43.strong_compare(weak_67aB43) + assert not weak_67ab43_one.strong_compare(weak_67ab43_two) + + assert not weak_67ab43_one.strong_compare(weak_67aB43) + assert not weak_67aB43.strong_compare(weak_67ab43_one) @pytest.mark.parametrize(

[ { "components": [ { "doc": "Parse a string containing one or more HTTP entity-tags.\n\nThe string is assumed to be formatted as defined for a precondition\nheader, and may contain either a single ETag, or multiple comma-separated\nETags. The string may also contain a '*' character, in order to ind...

[ "tests/test_request_attrs.py::TestRequestAttributes::test_missing_qs", "tests/test_request_attrs.py::TestRequestAttributes::test_empty", "tests/test_request_attrs.py::TestRequestAttributes::test_host", "tests/test_request_attrs.py::TestRequestAttributes::test_subdomain", "tests/test_request_attrs.py::TestRe...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat(etag): Improve etag performance and docs, plus usability of the ETag class ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in falcon/request_helpers.py] (definition of _parse_etags:) def _parse_etags(etag_str): """Parse a string containing one or more HTTP entity-tags. The string is assumed to be formatted as defined for a precondition header, and may contain either a single ETag, or multiple comma-separated ETags. The string may also contain a '*' character, in order to indicate that any ETag should match the precondition. (See also: RFC 7232, Section 3) Args: etag_str (str): An ASCII header value to parse ETags from. ETag values within may be prefixed by ``W/`` to indicate that the weak comparison function should be used. Returns: list: A list of unquoted ETags or ``['*']`` if all ETags should be matched. If the string to be parse is empty, or contains only whitespace, ``None`` will be returned instead.""" [end of new definitions in falcon/request_helpers.py] [start of new definitions in falcon/util/structures.py] (definition of ETag.strong_compare:) def strong_compare(self, other): """Performs a strong entity-tag comparison. Two entity-tags are equivalent if both are not weak and their opaque-tags match character-by-character. (See also: RFC 7232, Section 2.3.2) Arguments: other (ETag): The other :class:`~.ETag` to which you are comparing this one. Returns: bool: ``True`` if the two entity-tags match, otherwise ``False``.""" (definition of ETag.dumps:) def dumps(self): """Serialize the ETag to a string suitable for use in a precondition header. (See also: RFC 7232, Section 2.3) Returns: str: An opaque quoted string, possibly prefixed by a weakness indicator ``W/``.""" (definition of ETag.loads:) def loads(cls, etag_str): """Class method that deserializes a single entity-tag string from a precondition header. Note: This method is meant to be used only for parsing a single entity-tag. It can not be used to parse a comma-separated list of values. (See also: RFC 7232, Section 2.3) Arguments: etag_str (str): An ASCII string representing a single entity-tag, as defined by RFC 7232. Returns: ETag: An instance of `~.ETag` representing the parsed entity-tag.""" [end of new definitions in falcon/util/structures.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

77d5e6394a88ead151c9469494749f95f06b24bf

sympy__sympy-16057

16,057

sympy/sympy

1.4

5d06d9fcb8a954fc3ce0a0d8a69f1fc331b82880

2019-02-23T21:16:17Z

diff --git a/sympy/physics/optics/__init__.py b/sympy/physics/optics/__init__.py index 77306ae3e775..fc815db56c78 100644 --- a/sympy/physics/optics/__init__.py +++ b/sympy/physics/optics/__init__.py @@ -30,6 +30,7 @@ from . import utils -from .utils import (refraction_angle, deviation, brewster_angle, lens_makers_formula, +from .utils import (refraction_angle, fresnel_coefficients, + deviation, brewster_angle, critical_angle, lens_makers_formula, mirror_formula, lens_formula, hyperfocal_distance, transverse_magnification) __all__.extend(utils.__all__) diff --git a/sympy/physics/optics/medium.py b/sympy/physics/optics/medium.py index 83c7afdce7bc..9fc033e92586 100644 --- a/sympy/physics/optics/medium.py +++ b/sympy/physics/optics/medium.py @@ -120,9 +120,15 @@ def speed(self): >>> m = Medium('m') >>> m.speed 299792458*meter/second + >>> m2 = Medium('m2', n=1) + >>> m.speed == m2.speed + True """ - return 1/sqrt(self._permittivity*self._permeability) + if self._permittivity is not None and self._permeability is not None: + return 1/sqrt(self._permittivity*self._permeability) + else: + return c/self._n @property def refractive_index(self): @@ -174,7 +180,8 @@ def permeability(self): def __str__(self): from sympy.printing import sstr - return type(self).__name__ + sstr(self.args) + return type(self).__name__ + ': ' + sstr([self._permittivity, + self._permeability, self._n]) def __lt__(self, other): """ diff --git a/sympy/physics/optics/utils.py b/sympy/physics/optics/utils.py index 015a47960fcc..599719d438fa 100644 --- a/sympy/physics/optics/utils.py +++ b/sympy/physics/optics/utils.py @@ -2,8 +2,10 @@ **Contains** * refraction_angle +* fresnel_coefficients * deviation * brewster_angle +* critical_angle * lens_makers_formula * mirror_formula * lens_formula @@ -15,7 +17,9 @@ __all__ = ['refraction_angle', 'deviation', + 'fresnel_coefficients', 'brewster_angle', + 'critical_angle', 'lens_makers_formula', 'mirror_formula', 'lens_formula', @@ -23,9 +27,10 @@ 'transverse_magnification' ] -from sympy import Symbol, sympify, sqrt, Matrix, acos, oo, Limit, atan2 +from sympy import Symbol, sympify, sqrt, Matrix, acos, oo, Limit, atan2, asin,\ +cos, sin, tan, I, cancel from sympy.core.compatibility import is_sequence -from sympy.geometry.line import Ray3D +from sympy.geometry.line import Ray3D, Point3D from sympy.geometry.util import intersection from sympy.geometry.plane import Plane from .medium import Medium @@ -171,6 +176,94 @@ def refraction_angle(incident, medium1, medium2, normal=None, plane=None): return Ray3D(intersection_pt, direction_ratio=drs) +def fresnel_coefficients(angle_of_incidence, medium1, medium2): + """ + This function uses Fresnel equations to calculate reflection and + transmission coefficients. Those are obtained for both polarisations + when the electric field vector is in the plane of incidence (labelled 'p') + and when the electric field vector is perpendicular to the plane of + incidence (labelled 's'). There are four real coefficients unless the + incident ray reflects in total internal in which case there are two complex + ones. Angle of incidence is the angle between the incident ray and the + surface normal. ``medium1`` and ``medium2`` can be ``Medium`` or any + sympifiable object. + + Parameters + ========== + + angle_of_incidence : sympifiable + + medium1 : Medium or sympifiable + Medium 1 or its refractive index + + medium2 : Medium or sympifiable + Medium 2 or its refractive index + + Returns a list with four real Fresnel coefficients: + [reflection p (TM), reflection s (TE), + transmission p (TM), transmission s (TE)] + If the ray is undergoes total internal reflection then returns a + list of two complex Fresnel coefficients: + [reflection p (TM), reflection s (TE)] + + Examples + ======== + + >>> from sympy.physics.optics import fresnel_coefficients + >>> fresnel_coefficients(0.3, 1, 2) + [0.317843553417859, -0.348645229818821, + 0.658921776708929, 0.651354770181179] + >>> fresnel_coefficients(0.6, 2, 1) + [-0.235625382192159 - 0.971843958291041*I, + 0.816477005968898 - 0.577377951366403*I] + + References + ========== + + https://en.wikipedia.org/wiki/Fresnel_equations + """ + + if isinstance(medium1, Medium): + n1 = medium1.refractive_index + else: + n1 = sympify(medium1) + + if isinstance(medium2, Medium): + n2 = medium2.refractive_index + else: + n2 = sympify(medium2) + + angle_of_refraction = asin(n1*sin(angle_of_incidence)/n2) + try: + angle_of_total_internal_reflection_onset = critical_angle(n1, n2) + except ValueError: + angle_of_total_internal_reflection_onset = None + + if angle_of_total_internal_reflection_onset == None or\ + angle_of_total_internal_reflection_onset > angle_of_incidence: + R_s = -sin(angle_of_incidence - angle_of_refraction)\ + /sin(angle_of_incidence + angle_of_refraction) + R_p = tan(angle_of_incidence - angle_of_refraction)\ + /tan(angle_of_incidence + angle_of_refraction) + T_s = 2*sin(angle_of_refraction)*cos(angle_of_incidence)\ + /sin(angle_of_incidence + angle_of_refraction) + T_p = 2*sin(angle_of_refraction)*cos(angle_of_incidence)\ + /(sin(angle_of_incidence + angle_of_refraction)\ + *cos(angle_of_incidence - angle_of_refraction)) + return [R_p, R_s, T_p, T_s] + else: + n = n2/n1 + R_s = cancel((cos(angle_of_incidence)-\ + I*sqrt(sin(angle_of_incidence)**2 - n**2))\ + /(cos(angle_of_incidence)+\ + I*sqrt(sin(angle_of_incidence)**2 - n**2))) + R_p = cancel((n**2*cos(angle_of_incidence)-\ + I*sqrt(sin(angle_of_incidence)**2 - n**2))\ + /(n**2*cos(angle_of_incidence)+\ + I*sqrt(sin(angle_of_incidence)**2 - n**2))) + return [R_p, R_s] + + def deviation(incident, medium1, medium2, normal=None, plane=None): """ This function calculates the angle of deviation of a ray @@ -287,6 +380,45 @@ def brewster_angle(medium1, medium2): return atan2(n2, n1) +def critical_angle(medium1, medium2): + """ + This function calculates the critical angle of incidence (marking the onset + of total internal) to Medium 2 from Medium 1 in radians. + + Parameters + ========== + + medium 1 : Medium or sympifiable + Refractive index of Medium 1 + medium 2 : Medium or sympifiable + Refractive index of Medium 1 + + Examples + ======== + + >>> from sympy.physics.optics import critical_angle + >>> critical_angle(1.33, 1) + 0.850908514477849 + + """ + n1, n2 = None, None + + if isinstance(medium1, Medium): + n1 = medium1.refractive_index + else: + n1 = sympify(medium1) + + if isinstance(medium2, Medium): + n2 = medium2.refractive_index + else: + n2 = sympify(medium2) + + if n2 > n1: + raise ValueError('Total internal reflection impossible for n1 < n2') + else: + return asin(n2/n1) + + def lens_makers_formula(n_lens, n_surr, r1, r2): """

diff --git a/sympy/physics/optics/tests/test_utils.py b/sympy/physics/optics/tests/test_utils.py index 0155302e7e7c..22afadfcb04c 100644 --- a/sympy/physics/optics/tests/test_utils.py +++ b/sympy/physics/optics/tests/test_utils.py @@ -1,6 +1,7 @@ -from sympy.physics.optics.utils import (refraction_angle, deviation, - brewster_angle, lens_makers_formula, mirror_formula, lens_formula, - hyperfocal_distance, transverse_magnification) +from sympy.physics.optics.utils import (refraction_angle, fresnel_coefficients, + deviation, brewster_angle, critical_angle, lens_makers_formula, + mirror_formula, lens_formula, hyperfocal_distance, + transverse_magnification) from sympy.physics.optics.medium import Medium from sympy.physics.units import e0 @@ -62,10 +63,22 @@ def test_refraction_angle(): Ray3D(Point3D(0, 0, 0), direction_ratio=[1, 1, -1]) +def test_fresnel_coefficients(): + assert list(round(i, 5) for i in fresnel_coefficients(0.5, 1, 1.33)) == \ + [0.11163, -0.17138, 0.83581, 0.82862] + assert list(round(i, 5) for i in fresnel_coefficients(0.5, 1.33, 1)) == \ + [-0.07726, 0.20482, 1.22724, 1.20482] + m1 = Medium('m1') + m2 = Medium('m2', n=2) + assert list(round(i, 5) for i in fresnel_coefficients(0.3, m1, m2)) == \ + [0.31784, -0.34865, 0.65892, 0.65135] + assert list(list(round(j, 5) for j in i.as_real_imag()) for i in \ + fresnel_coefficients(0.6, m2, m1)) == \ + [[-0.23563, -0.97184], [0.81648, -0.57738]] + + def test_deviation(): n1, n2 = symbols('n1, n2') - m1 = Medium('m1') - m2 = Medium('m2') r1 = Ray3D(Point3D(-1, -1, 1), Point3D(0, 0, 0)) n = Matrix([0, 0, 1]) i = Matrix([-1, -1, -1]) @@ -81,11 +94,20 @@ def test_deviation(): def test_brewster_angle(): + m1 = Medium('m1', n=1) + m2 = Medium('m2', n=1.33) + assert round(brewster_angle(m1, m2), 2) == 0.93 m1 = Medium('m1', permittivity=e0, n=1) m2 = Medium('m2', permittivity=e0, n=1.33) assert round(brewster_angle(m1, m2), 2) == 0.93 +def test_critical_angle(): + m1 = Medium('m1', n=1) + m2 = Medium('m2', n=1.33) + assert round(critical_angle(m2, m1), 2) == 0.85 + + def test_lens_makers_formula(): n1, n2 = symbols('n1, n2') m1 = Medium('m1', permittivity=e0, n=1)

[ { "components": [ { "doc": "This function uses Fresnel equations to calculate reflection and\ntransmission coefficients. Those are obtained for both polarisations\nwhen the electric field vector is in the plane of incidence (labelled 'p')\nand when the electric field vector is perpendicular to the...

[ "test_refraction_angle", "test_fresnel_coefficients", "test_deviation", "test_brewster_angle", "test_critical_angle", "test_lens_makers_formula", "test_mirror_formula", "test_lens_formula", "test_hyperfocal_distance" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Calculation of critical angle and Fresnel coefficients  * physics.optics * Added two new functions to `physics.optics.utils`: 1) `critical_angle() `calculates the onset of total internal reflection, "TIR" when possible (n2 < n1) 2) `fresnel_coefficients()` calculates real reflection and transmission coefficients when out of TIR and complex ones when the ray is TIR'ed  * Small fix: calculating speed of light in medium is possible given only the refractive index. * Associated tests * The motivation for the above being that SymPy is well-suited to become a basic 'optics calculator' which would be a go-to tool for small tasks especially given that it can be used via SymPy Live. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/physics/optics/utils.py] (definition of fresnel_coefficients:) def fresnel_coefficients(angle_of_incidence, medium1, medium2): """This function uses Fresnel equations to calculate reflection and transmission coefficients. Those are obtained for both polarisations when the electric field vector is in the plane of incidence (labelled 'p') and when the electric field vector is perpendicular to the plane of incidence (labelled 's'). There are four real coefficients unless the incident ray reflects in total internal in which case there are two complex ones. Angle of incidence is the angle between the incident ray and the surface normal. ``medium1`` and ``medium2`` can be ``Medium`` or any sympifiable object. Parameters ========== angle_of_incidence : sympifiable medium1 : Medium or sympifiable Medium 1 or its refractive index medium2 : Medium or sympifiable Medium 2 or its refractive index Returns a list with four real Fresnel coefficients: [reflection p (TM), reflection s (TE), transmission p (TM), transmission s (TE)] If the ray is undergoes total internal reflection then returns a list of two complex Fresnel coefficients: [reflection p (TM), reflection s (TE)] Examples ======== >>> from sympy.physics.optics import fresnel_coefficients >>> fresnel_coefficients(0.3, 1, 2) [0.317843553417859, -0.348645229818821, 0.658921776708929, 0.651354770181179] >>> fresnel_coefficients(0.6, 2, 1) [-0.235625382192159 - 0.971843958291041*I, 0.816477005968898 - 0.577377951366403*I] References ========== https://en.wikipedia.org/wiki/Fresnel_equations""" (definition of critical_angle:) def critical_angle(medium1, medium2): """This function calculates the critical angle of incidence (marking the onset of total internal) to Medium 2 from Medium 1 in radians. Parameters ========== medium 1 : Medium or sympifiable Refractive index of Medium 1 medium 2 : Medium or sympifiable Refractive index of Medium 1 Examples ======== >>> from sympy.physics.optics import critical_angle >>> critical_angle(1.33, 1) 0.850908514477849""" [end of new definitions in sympy/physics/optics/utils.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

e941ad69638189ea42507331e417b88837357dec

pyocd__pyOCD-540

540

pyocd/pyOCD

null

31c3ca684cb7b595662d1fd378a9272e1e6ac8fe

2019-02-16T22:43:45Z

diff --git a/pyocd/board/board.py b/pyocd/board/board.py index 9e3eea1c2..7efee6015 100644 --- a/pyocd/board/board.py +++ b/pyocd/board/board.py @@ -17,16 +17,19 @@ from ..target import TARGET from ..target.pack import pack_target +from ..utility.graph import GraphNode import logging import six log = logging.getLogger('board') -class Board(object): +class Board(GraphNode): """ This class associates a target and flash to create a board. """ def __init__(self, session, target=None): + super(Board, self).__init__() + # As a last resort, default the target to 'cortex_m'. if target is None: target = 'cortex_m' @@ -47,6 +50,8 @@ def __init__(self, session, target=None): log.error("target '%s' not recognized", self._target_type) six.raise_from(KeyError("target '%s' not recognized" % self._target_type), exc) self._inited = False + + self.add_child(self.target) ## @brief Initialize the board. def init(self): diff --git a/pyocd/core/coresight_target.py b/pyocd/core/coresight_target.py index fc1c297d4..6409d0d96 100644 --- a/pyocd/core/coresight_target.py +++ b/pyocd/core/coresight_target.py @@ -24,6 +24,7 @@ from ..debug.cache import CachingDebugContext from ..debug.elf.elf import ELFBinaryFile from ..debug.elf.flash_reader import FlashReaderContext +from ..utility.graph import GraphNode from ..utility.notification import Notification from ..utility.sequencer import CallSequence from ..target.pack.flash_algo import PackFlashAlgo @@ -46,10 +47,11 @@ # the CortexM object for the core. Multicore devices work differently. This class tracks # a "selected core", to which all actions are directed. The selected core can be changed # at any time. You may also directly access specific cores and perform operations on them. -class CoreSightTarget(Target): +class CoreSightTarget(Target, GraphNode): def __init__(self, session, memoryMap=None): - super(CoreSightTarget, self).__init__(session, memoryMap) + Target.__init__(self, session, memoryMap) + GraphNode.__init__(self) self.root_target = self self.part_number = self.__class__.__name__ self.cores = {} @@ -114,6 +116,7 @@ def add_core(self, core): core.delegate = self.delegate core.set_target_context(CachingDebugContext(DebugContext(core))) self.cores[core.core_number] = core + self.add_child(core) self._root_contexts[core.core_number] = None def create_init_sequence(self): @@ -189,6 +192,7 @@ def create_flash(self): region.flash = obj def _create_component(self, cmpid): + logging.debug("Creating %s component", cmpid.name) cmp = cmpid.factory(cmpid.ap, cmpid, cmpid.address) cmp.init() diff --git a/pyocd/coresight/component.py b/pyocd/coresight/component.py index bc9bca254..def825a68 100644 --- a/pyocd/coresight/component.py +++ b/pyocd/coresight/component.py @@ -1,5 +1,5 @@ # pyOCD debugger -# Copyright (c) 2018 Arm Limited +# Copyright (c) 2018-2019 Arm Limited # SPDX-License-Identifier: Apache-2.0 # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -14,17 +14,15 @@ # See the License for the specific language governing permissions and # limitations under the License. -import logging +from ..utility.graph import GraphNode -log = logging.getLogger("component") +class CoreSightComponent(GraphNode): + """! @brief CoreSight component base class.""" -## @brief CoreSight component base class. -# -# x -class CoreSightComponent(object): - ## @brief Constructor. - # def __init__(self, ap, cmpid=None, addr=None): + """! @brief Constructor.""" + super(CoreSightComponent, self).__init__() + """! @brief Constructor.""" self._ap = ap self._cmpid = cmpid self._address = addr or (cmpid.address if cmpid else None) diff --git a/pyocd/coresight/cortex_m.py b/pyocd/coresight/cortex_m.py index d1d894d73..0324ff727 100644 --- a/pyocd/coresight/cortex_m.py +++ b/pyocd/coresight/cortex_m.py @@ -430,7 +430,9 @@ def __init__(self, rootTarget, ap, memoryMap=None, core_num=0, cmpid=None, addre self.bp_manager.add_provider(self.sw_bp, Target.BREAKPOINT_SW) ## @brief Connect related CoreSight components. - def connect(self, cmp): + def add_child(self, cmp): + super(CortexM, self).add_child(cmp) + if isinstance(cmp, FPB): self.fpb = cmp self.bp_manager.add_provider(cmp, Target.BREAKPOINT_HW) diff --git a/pyocd/coresight/dwt.py b/pyocd/coresight/dwt.py index 88710e093..aa704fd2c 100644 --- a/pyocd/coresight/dwt.py +++ b/pyocd/coresight/dwt.py @@ -58,7 +58,7 @@ class DWT(CoreSightComponent): def factory(cls, ap, cmpid, address): dwt = cls(ap, cmpid, address) assert ap.core - ap.core.connect(dwt) + ap.core.add_child(dwt) return dwt def __init__(self, ap, cmpid=None, addr=None): diff --git a/pyocd/coresight/fpb.py b/pyocd/coresight/fpb.py index b93486540..ceb6d38d0 100644 --- a/pyocd/coresight/fpb.py +++ b/pyocd/coresight/fpb.py @@ -37,7 +37,7 @@ class FPB(BreakpointProvider, CoreSightComponent): def factory(cls, ap, cmpid, address): fpb = cls(ap, cmpid, address) assert ap.core - ap.core.connect(fpb) + ap.core.add_child(fpb) return fpb def __init__(self, ap, cmpid=None, addr=None): diff --git a/pyocd/coresight/rom_table.py b/pyocd/coresight/rom_table.py index 1f083b07a..4f4a2f1bd 100644 --- a/pyocd/coresight/rom_table.py +++ b/pyocd/coresight/rom_table.py @@ -262,7 +262,8 @@ def __init__(self, ap, cmpid=None, addr=None, parent_table=None): if addr is None: addr = ap.rom_addr super(ROMTable, self).__init__(ap, cmpid, addr) - self.parent = parent_table + if parent_table is not None: + parent_table.add_child(self) self.number = (self.parent.number + 1) if self.parent else 0 self.components = [] self.name = 'ROM' diff --git a/pyocd/utility/graph.py b/pyocd/utility/graph.py new file mode 100644 index 000000000..5176281b4 --- /dev/null +++ b/pyocd/utility/graph.py @@ -0,0 +1,92 @@ +# pyOCD debugger +# Copyright (c) 2019 Arm Limited +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +class GraphNode(object): + """! @brief Simple graph node.""" + + def __init__(self): + """! @brief Constructor.""" + super(GraphNode, self).__init__() + self._parent = None + self._children = [] + + @property + def parent(self): + """! @brief This node's parent in the object graph.""" + return self._parent + + @property + def children(self): + """! @brief Child nodes in the object graph.""" + return self._children + + def add_child(self, node): + """! @brief Link a child node onto this object.""" + node._parent = self + self._children.append(node) + + def find_children(self, predicate, breadth_first=True): + """! @brief Recursively search for children that match a given predicate. + @param self + @param predicate A callable accepting a single argument for the node to examine. If the + predicate returns True, then that node is added to the result list and no further + searches on that node's children are performed. A False predicate result causes the + node's children to be searched. + @param breadth_first Whether to search breadth first. Pass False to search depth first. + @returns List of matching child nodes, or an empty list if no matches were found. + """ + def _search(node, klass): + results = [] + childrenToExamine = [] + for child in node.children: + if predicate(child): + results.append(child) + elif not breadth_first: + results.extend(_search(child, klass)) + elif breadth_first: + childrenToExamine.append(child) + + if breadth_first: + for child in childrenToExamine: + results.extend(_search(child, klass)) + return results + + return _search(self, predicate) + + def get_first_child_of_type(self, klass): + """! @brief Breadth-first search for a child of the given class. + @param self + @param klass The class type to search for. The first child at any depth that is an instance + of this class or a subclass thereof will be returned. Matching children at more shallow + nodes will take precedence over deeper nodes. + @returns Either a node object or None. + """ + matches = self.find_children(lambda c: isinstance(c, klass)) + if len(matches): + return matches[0] + else: + return None + +def dump_graph(node): + """! @brief Draw the object graph.""" + + def _dump(node, level): + name = node.__class__.__name__ + print(" " * level + "- " + name) + for child in node.children: + _dump(child, level + 1) + + _dump(node, 0)

diff --git a/pyocd/test/test_graph.py b/pyocd/test/test_graph.py new file mode 100644 index 000000000..c5a81ceb0 --- /dev/null +++ b/pyocd/test/test_graph.py @@ -0,0 +1,110 @@ +# pyOCD debugger +# Copyright (c) 2019 Arm Limited +# SPDX-License-Identifier: Apache-2.0 +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from pyocd.utility.graph import GraphNode +import pytest + +class BaseNode(GraphNode): + def __init__(self, value): + super(BaseNode, self).__init__() + self.value = value + + def __repr__(self): + return "<{}@{:#010x} {}".format(self.__class__.__name__, id(self), self.value) + +class NodeA(BaseNode): + pass + +class NodeB(BaseNode): + pass + +@pytest.fixture(scope='function') +def a(): + return NodeA(23) + +@pytest.fixture(scope='function') +def b(): + return NodeB(1) + +@pytest.fixture(scope='function') +def c(): + return NodeB(2) + +@pytest.fixture(scope='function') +def graph(a, b, c): + p = GraphNode() + p.add_child(a) + a.add_child(b) + p.add_child(c) + return p + +class TestGraph: + def test_new(self): + n = GraphNode() + assert len(n.children) == 0 + assert n.parent is None + + def test_add_child(self): + p = GraphNode() + a = GraphNode() + p.add_child(a) + assert p.children == [a] + assert p.parent is None + assert a.parent is p + assert a.children == [] + + def test_multiple_child(self): + p = GraphNode() + a = GraphNode() + b = GraphNode() + c = GraphNode() + p.add_child(a) + p.add_child(b) + p.add_child(c) + assert p.children == [a, b, c] + assert p.parent is None + assert a.parent is p + assert b.parent is p + assert c.parent is p + assert a.children == [] + assert b.children == [] + assert c.children == [] + + def test_multilevel(self, graph, a, b, c): + assert len(graph.children) == 2 + assert graph.children == [a, c] + assert len(a.children) == 1 + assert a.children == [b] + assert graph.parent is None + assert a.parent is graph + assert b.parent is a + assert c.parent is graph + assert b.children == [] + assert c.children == [] + + def test_find_breadth(self, graph, a, b, c): + assert graph.find_children(lambda n: n.value == 1) == [b] + assert graph.find_children(lambda n: n.value == 1 or n.value == 2) == [c, b] + + def test_find_depth(self, graph, a, b, c): + assert graph.find_children(lambda n: n.value == 1, breadth_first=False) == [b] + assert graph.find_children(lambda n: n.value == 1 or n.value == 2, breadth_first=False) == [b, c] + + def test_first(self, graph, a, b, c): + assert graph.get_first_child_of_type(NodeA) == a + assert graph.get_first_child_of_type(NodeB) == c + assert a.get_first_child_of_type(NodeB) == b +

[ { "components": [ { "doc": "", "lines": [ 433, 440 ], "name": "CortexM.add_child", "signature": "def add_child(self, cmp):", "type": "function" } ], "file": "pyocd/coresight/cortex_m.py" }, { "components": [ { ...

[ "pyocd/test/test_graph.py::TestGraph::test_new", "pyocd/test/test_graph.py::TestGraph::test_add_child", "pyocd/test/test_graph.py::TestGraph::test_multiple_child", "pyocd/test/test_graph.py::TestGraph::test_multilevel", "pyocd/test/test_graph.py::TestGraph::test_find_breadth", "pyocd/test/test_graph.py::T...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Generic object graph This PR creates a more explicit graph out of the various objects in a session. A `GraphNode` base class is added that provides parent and child links, plus a couple methods to search for children. The goal here is to make the relationships between objects more apparent, and to make it easier to find various objects as the graph becomes more complicated with additional CoreSight components being supported. Classes will still have explicit references to the other objects they need to function, such as the `fpb` and `dwt` attributes on `CortexM`. But it is now possible to connect other components in the graph even if the parent doesn't directly use or support the child, for instance ITM or TPIU being associated with a core. Finally, this makes it easier to find components if they move around in the graph due to different CoreSight configurations, such as a TPIU being shared between multiple cores versus being attached directly to a single core. ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pyocd/coresight/cortex_m.py] (definition of CortexM.add_child:) def add_child(self, cmp): [end of new definitions in pyocd/coresight/cortex_m.py] [start of new definitions in pyocd/utility/graph.py] (definition of GraphNode:) class GraphNode(object): """! @brief Simple graph node.""" (definition of GraphNode.__init__:) def __init__(self): """! @brief Constructor.""" (definition of GraphNode.parent:) def parent(self): """! @brief This node's parent in the object graph.""" (definition of GraphNode.children:) def children(self): """! @brief Child nodes in the object graph.""" (definition of GraphNode.add_child:) def add_child(self, node): """! @brief Link a child node onto this object.""" (definition of GraphNode.find_children:) def find_children(self, predicate, breadth_first=True): """! @brief Recursively search for children that match a given predicate. @param self @param predicate A callable accepting a single argument for the node to examine. If the predicate returns True, then that node is added to the result list and no further searches on that node's children are performed. A False predicate result causes the node's children to be searched. @param breadth_first Whether to search breadth first. Pass False to search depth first. @returns List of matching child nodes, or an empty list if no matches were found.""" (definition of GraphNode.find_children._search:) def _search(node, klass): (definition of GraphNode.get_first_child_of_type:) def get_first_child_of_type(self, klass): """! @brief Breadth-first search for a child of the given class. @param self @param klass The class type to search for. The first child at any depth that is an instance of this class or a subclass thereof will be returned. Matching children at more shallow nodes will take precedence over deeper nodes. @returns Either a node object or None.""" (definition of dump_graph:) def dump_graph(node): """! @brief Draw the object graph.""" (definition of dump_graph._dump:) def _dump(node, level): [end of new definitions in pyocd/utility/graph.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

fe7d737424be818daa1d55ecbd59be1a0dffdf5b

sympy__sympy-15994

15,994

sympy/sympy

1.4

6f6707f96a51db7d49f59d0e26d2df95acbfc33f

2019-02-15T19:56:26Z

diff --git a/sympy/matrices/expressions/matadd.py b/sympy/matrices/expressions/matadd.py index 22315096ce33..1c28021249ed 100644 --- a/sympy/matrices/expressions/matadd.py +++ b/sympy/matrices/expressions/matadd.py @@ -8,8 +8,9 @@ from sympy.matrices.matrices import MatrixBase from sympy.matrices.expressions.transpose import transpose from sympy.strategies import (rm_id, unpack, flatten, sort, condition, - exhaust, do_one, glom) -from sympy.matrices.expressions.matexpr import MatrixExpr, ShapeError, ZeroMatrix + exhaust, do_one, glom) +from sympy.matrices.expressions.matexpr import (MatrixExpr, ShapeError, + ZeroMatrix, GenericZeroMatrix) from sympy.utilities import default_sort_key, sift from sympy.core.operations import AssocOp @@ -32,6 +33,12 @@ class MatAdd(MatrixExpr, Add): is_MatAdd = True def __new__(cls, *args, **kwargs): + if not args: + return GenericZeroMatrix() + + # This must be removed aggressively in the constructor to avoid + # TypeErrors from GenericZeroMatrix().shape + args = filter(lambda i: GenericZeroMatrix() != i, args) args = list(map(sympify, args)) check = kwargs.get('check', False) diff --git a/sympy/matrices/expressions/matexpr.py b/sympy/matrices/expressions/matexpr.py index 124e9994e25e..69124d89fe7a 100644 --- a/sympy/matrices/expressions/matexpr.py +++ b/sympy/matrices/expressions/matexpr.py @@ -738,6 +738,10 @@ def cols(self): def shape(self): return (self.args[0], self.args[0]) + @property + def is_square(self): + return True + def _eval_transpose(self): return self @@ -761,6 +765,39 @@ def _entry(self, i, j, **kwargs): def _eval_determinant(self): return S.One +class GenericIdentity(Identity): + """ + An identity matrix without a specified shape + + This exists primarily so MatMul() with no arguments can return something + meaningful. + """ + def __new__(cls): + # super(Identity, cls) instead of super(GenericIdentity, cls) because + # Identity.__new__ doesn't have the same signature + return super(Identity, cls).__new__(cls) + + @property + def rows(self): + raise TypeError("GenericIdentity does not have a specified shape") + + @property + def cols(self): + raise TypeError("GenericIdentity does not have a specified shape") + + @property + def shape(self): + raise TypeError("GenericIdentity does not have a specified shape") + + # Avoid Matrix.__eq__ which might call .shape + def __eq__(self, other): + return isinstance(other, GenericIdentity) + + def __ne__(self, other): + return not (self == other) + + def __hash__(self): + return super(GenericIdentity, self).__hash__() class ZeroMatrix(MatrixExpr): """The Matrix Zero 0 - additive identity @@ -816,6 +853,40 @@ def __nonzero__(self): __bool__ = __nonzero__ +class GenericZeroMatrix(ZeroMatrix): + """ + A zero matrix without a specified shape + + This exists primarily so MatAdd() with no arguments can return something + meaningful. + """ + def __new__(cls): + # super(ZeroMatrix, cls) instead of super(GenericZeroMatrix, cls) + # because ZeroMatrix.__new__ doesn't have the same signature + return super(ZeroMatrix, cls).__new__(cls) + + @property + def rows(self): + raise TypeError("GenericZeroMatrix does not have a specified shape") + + @property + def cols(self): + raise TypeError("GenericZeroMatrix does not have a specified shape") + + @property + def shape(self): + raise TypeError("GenericZeroMatrix does not have a specified shape") + + # Avoid Matrix.__eq__ which might call .shape + def __eq__(self, other): + return isinstance(other, GenericZeroMatrix) + + def __ne__(self, other): + return not (self == other) + + + def __hash__(self): + return super(GenericZeroMatrix, self).__hash__() def matrix_symbols(expr): return [sym for sym in expr.free_symbols if sym.is_Matrix] diff --git a/sympy/matrices/expressions/matmul.py b/sympy/matrices/expressions/matmul.py index fb861a70bafb..cff91f73f708 100644 --- a/sympy/matrices/expressions/matmul.py +++ b/sympy/matrices/expressions/matmul.py @@ -8,7 +8,7 @@ from sympy.strategies import (rm_id, unpack, typed, flatten, exhaust, do_one, new) from sympy.matrices.expressions.matexpr import (MatrixExpr, ShapeError, - Identity, ZeroMatrix) + Identity, ZeroMatrix, GenericIdentity) from sympy.matrices.expressions.matpow import MatPow from sympy.matrices.matrices import MatrixBase @@ -31,12 +31,22 @@ class MatMul(MatrixExpr, Mul): def __new__(cls, *args, **kwargs): check = kwargs.get('check', True) + + if not args: + return GenericIdentity() + + # This must be removed aggressively in the constructor to avoid + # TypeErrors from GenericIdentity().shape + args = filter(lambda i: GenericIdentity() != i, args) args = list(map(sympify, args)) obj = Basic.__new__(cls, *args) factor, matrices = obj.as_coeff_matrices() if check: validate(*matrices) if not matrices: + # Should it be + # + # return Basic.__neq__(cls, factor, GenericIdentity()) ? return factor return obj

diff --git a/sympy/core/tests/test_args.py b/sympy/core/tests/test_args.py index dc98b2191cf1..5895f1ca842c 100644 --- a/sympy/core/tests/test_args.py +++ b/sympy/core/tests/test_args.py @@ -2666,6 +2666,9 @@ def test_sympy__matrices__expressions__matexpr__Identity(): from sympy.matrices.expressions.matexpr import Identity assert _test_args(Identity(3)) +def test_sympy__matrices__expressions__matexpr__GenericIdentity(): + from sympy.matrices.expressions.matexpr import GenericIdentity + assert _test_args(GenericIdentity()) @SKIP("abstract class") def test_sympy__matrices__expressions__matexpr__MatrixExpr(): @@ -2686,6 +2689,9 @@ def test_sympy__matrices__expressions__matexpr__ZeroMatrix(): from sympy.matrices.expressions.matexpr import ZeroMatrix assert _test_args(ZeroMatrix(3, 5)) +def test_sympy__matrices__expressions__matexpr__GenericZeroMatrix(): + from sympy.matrices.expressions.matexpr import GenericZeroMatrix + assert _test_args(GenericZeroMatrix()) def test_sympy__matrices__expressions__matmul__MatMul(): from sympy.matrices.expressions.matmul import MatMul diff --git a/sympy/matrices/expressions/tests/test_matexpr.py b/sympy/matrices/expressions/tests/test_matexpr.py index ace95c2802fb..21c92ea8e8fc 100644 --- a/sympy/matrices/expressions/tests/test_matexpr.py +++ b/sympy/matrices/expressions/tests/test_matexpr.py @@ -8,7 +8,8 @@ from sympy.matrices import (Identity, ImmutableMatrix, Inverse, MatAdd, MatMul, MatPow, Matrix, MatrixExpr, MatrixSymbol, ShapeError, ZeroMatrix, SparseMatrix, Transpose, Adjoint) -from sympy.matrices.expressions.matexpr import MatrixElement +from sympy.matrices.expressions.matexpr import (MatrixElement, + GenericZeroMatrix, GenericIdentity) from sympy.utilities.pytest import raises @@ -360,3 +361,42 @@ def test_issue_2749(): def test_issue_2750(): x = MatrixSymbol('x', 1, 1) assert (x.T*x).as_explicit()**-1 == Matrix([[x[0, 0]**(-2)]]) + +def test_generic_zero_matrix(): + z = GenericZeroMatrix() + A = MatrixSymbol("A", n, n) + + assert z == z + assert z != A + assert A != z + + assert z.is_ZeroMatrix + + raises(TypeError, lambda: z.shape) + raises(TypeError, lambda: z.rows) + raises(TypeError, lambda: z.cols) + + assert MatAdd() == z + assert MatAdd(z, A) == MatAdd(A) + # Make sure it is hashable + hash(z) + +def test_generic_identity(): + I = GenericIdentity() + A = MatrixSymbol("A", n, n) + + assert I == I + assert I != A + assert A != I + + assert I.is_Identity + assert I**-1 == I + + raises(TypeError, lambda: I.shape) + raises(TypeError, lambda: I.rows) + raises(TypeError, lambda: I.cols) + + assert MatMul() == I + assert MatMul(I, A) == MatMul(A) + # Make sure it is hashable + hash(I)

[ { "components": [ { "doc": "", "lines": [ 742, 743 ], "name": "Identity.is_square", "signature": "def is_square(self):", "type": "function" }, { "doc": "An identity matrix without a specified shape\n\nThis exists prima...

[ "test_sympy__matrices__expressions__matexpr__GenericIdentity", "test_sympy__matrices__expressions__matexpr__GenericZeroMatrix", "test_shape", "test_matexpr", "test_subs", "test_ZeroMatrix", "test_ZeroMatrix_doit", "test_Identity", "test_Identity_doit", "test_addition", "test_multiplication", "...

[ "test_all_classes_are_tested", "test_sympy__assumptions__assume__AppliedPredicate", "test_sympy__assumptions__assume__Predicate", "test_sympy__assumptions__sathandlers__UnevaluatedOnFree", "test_sympy__assumptions__sathandlers__AllArgs", "test_sympy__assumptions__sathandlers__AnyArgs", "test_sympy__assu...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Add GenericZeroMatrix and GenericIdentity class in matrix expressions These are generic in the sense that they have no shape (.shape raises a TypeError). They are returned by MatAdd() and MatMul() with no arguments. In order to avoid the TypeErrors being an issue, MatAdd and MatMul remove them unconditionally in their constructors (normally they are completely unevaluated without calling doit()). closes #15986 as an alternative. See the discussion there and at https://github.com/sympy/sympy/pull/15948#issuecomment-463432718.  #### References to other Issues or PRs  #### Brief description of what is fixed or changed #### Other comments #### Release Notes   * matrices * `MatAdd()` and `MatMul()` now return generic zero and identity matrices with no specified shape.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/matrices/expressions/matexpr.py] (definition of Identity.is_square:) def is_square(self): (definition of GenericIdentity:) class GenericIdentity(Identity): """An identity matrix without a specified shape This exists primarily so MatMul() with no arguments can return something meaningful.""" (definition of GenericIdentity.__new__:) def __new__(cls): (definition of GenericIdentity.rows:) def rows(self): (definition of GenericIdentity.cols:) def cols(self): (definition of GenericIdentity.shape:) def shape(self): (definition of GenericIdentity.__eq__:) def __eq__(self, other): (definition of GenericIdentity.__ne__:) def __ne__(self, other): (definition of GenericIdentity.__hash__:) def __hash__(self): (definition of GenericZeroMatrix:) class GenericZeroMatrix(ZeroMatrix): """A zero matrix without a specified shape This exists primarily so MatAdd() with no arguments can return something meaningful.""" (definition of GenericZeroMatrix.__new__:) def __new__(cls): (definition of GenericZeroMatrix.rows:) def rows(self): (definition of GenericZeroMatrix.cols:) def cols(self): (definition of GenericZeroMatrix.shape:) def shape(self): (definition of GenericZeroMatrix.__eq__:) def __eq__(self, other): (definition of GenericZeroMatrix.__ne__:) def __ne__(self, other): (definition of GenericZeroMatrix.__hash__:) def __hash__(self): [end of new definitions in sympy/matrices/expressions/matexpr.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Add UndefinedMatrixShapeSymbol class This can be used as a symbolic shape in a matrix expression, and will not result in errors when compared to a different shape. For instance, _n = UndefinedMatrixShapeSymbol('_n') k = Symbol('k') A = MatrixSymbol("A", _n, _n) B = MatrixSymbol("B", k, k) A + B # does not result in an error In particular, MatAdd() and MatMul() with no arguments now return a ZeroMatrix and Identity with Dummy UndefinedMatrixShapeSymbol, rather than scalar 0 and 1. Also makes it so that is_square returns None if one of the arguments has an UndefinedMatrixShapeSymbol. I'm still not 100% sure if this is a good idea. I'd like feedback on it. It does fix the issue described at https://github.com/sympy/sympy/pull/15948#issuecomment-463432718. Although with it, `cancel` returns matrices with unevaluated `0` and `I` matrices, so we probably should add better automatic simplification of these.  #### References to other Issues or PRs  #### Brief description of what is fixed or changed #### Other comments #### Release Notes   * matrices * new class in `sympy.matrices.expressions.matexpr`, `UndefinedMatrixShapeSymbol`, which can be used in symbolic matrix shapes to not compare unequal to other matrix shapes for the purposes of type checking. * `MatAdd()` and `MatMul()` with no arguments now return `ZeroMatrix` and `Identity` with Dummy `UndefinedMatrixShapeSymbol`, resp. * `MatrixExpr.is_square` returns `None` if the shape contains an `UndefinedMatrixShapeSymbol`.  ---------- Another alternative to this would be to simply be less aggressive with type checking in the matrix expressions. I think that would be a much harder change, and we do want to do type checking at some point, so it's not clear where it should be done and not done. I wonder if we could have a Chameleon (Symbol) which always passes `Eq(Chameleon(), foo)` but not `Eq(Chameleon(), Chameleon())`? Being always equal to everything could cause issues. It could get swapped out for things that SymPy thinks it is equal to. For instance it would be impossible to `subs` the chameleon with something else because subs would think the first expression it comes across is equal to it. > could cause issues crumple, crumple, toss. We have PurePoly with a common symbol. Could we have a Symbol that is recognized as being an arbitrary integer: `IntSymbol('n') == IntSymbol('n') != IntSymbol('m')`? I'm not sure about it. We really only need to bypass the type checks, which are basically three places in the code, the check that the shapes are equal in MatAdd, the check that rows == cols in MatMul, and the check for is_square in Inverse. To take a step back, the problem that we are trying to solve is to make matrix expressions work with any function that already works with noncommutative Symbols. The problem is that MatAdd and MatMul subclass from Add and Mul, but there are some ways that they don't behave the same, leading to errors from any algorithm that assumes they do. One of these ways is that you can't add 0 to a matrix expression, because 0 is a scalar and doesn't have the proper shape. You also can't create an empty `MatAdd()` or `MatMul()`, which causes issues with functions like the one in https://github.com/sympy/sympy/pull/15948#issuecomment-463432718 which call `expr.func(*l)` where `l` could be empty. For `Add()` and `Mul()` those are obviously the identities `0` and `1`, but for `MatAdd()` and `MatMul()` the exact identity depends on the shape of the matrix. Actually, since this is really only needed for ZeroMatrix and Identity, maybe instead of doing this with the shape parameter, we could create special ZeroMatrix and Identity objects that don't have a specified shape (the `.shape` could raise an exception). As long as these are aggressively removed once they are part of a larger expression, it might work. By "aggressively" I mean MatAdd and MatMul should remove them even without calling `doit` (unlike `Add` and `Mul`,`MatAdd` and `MatMul` are completely unevaluated by default). Would it suffice to define two special matrix expressions, `MatZero` and `MatOne`? -------------------- </issues>

e941ad69638189ea42507331e417b88837357dec

falconry__falcon-1447

1,447

falconry/falcon

null

35d5220c7ee359ac6b03788107a194644eb00344

2019-02-14T07:30:05Z

diff --git a/CHANGES.rst b/CHANGES.rst index bf705ab82..54c3a289a 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -61,6 +61,9 @@ Breaking Changes Falcon detects that it is running on the wsgiref server. If you need to normalize stream semantics between wsgiref and a production WSGI server, ``Request.bounded_stream`` may be used instead. +- ``Request.cookies`` now gives precedence to the first value + encountered in the Cookie header for a given cookie name, rather than the + last. Changes to Supported Platforms ------------------------------ @@ -109,6 +112,11 @@ New & Improved ``dumps()`` and ``loads()`` functions. This enables support not only for using any of a number of third-party JSON libraries, but also for customizing the keyword arguments used when (de)serializing objects. +- Added a new method, ``get_cookie_values()``, to the ``Request`` + class. The new method supports getting all values provided for a given + cookie, and is now the preferred mechanism for reading request cookies. +- Optimized request cookie parsing. It is now roughly an order of magnitude + faster. - ``append_header()`` now supports appending raw Set-Cookie header values. Fixed diff --git a/docs/api/cookies.rst b/docs/api/cookies.rst index dbfc918bf..828780c08 100644 --- a/docs/api/cookies.rst +++ b/docs/api/cookies.rst @@ -3,15 +3,16 @@ Cookies ------- -Cookie support is available in Falcon version 0.3 or later. - .. _getting-cookies: Getting Cookies ~~~~~~~~~~~~~~~ -Cookies can be read from a request via the :py:attr:`~.Request.cookies` -request attribute: +Cookies can be read from a request either via the +:py:meth:`~.Request.get_cookie_values` method or the :py:attr:`~.Request.cookies` +attribute on the :py:class:`~.Request` object. Generally speaking, the +:py:meth:`~.Request.get_cookie_values` method should be used unless you need a +collection of all the cookies in the request. .. code:: python @@ -20,13 +21,13 @@ request attribute: cookies = req.cookies - if 'my_cookie' in cookies: - my_cookie_value = cookies['my_cookie'] - # .... + my_cookie_values = req.get_cookie_values('my_cookie') + if my_cookie_values: + # NOTE: If there are multiple values set for the cookie, you + # will need to choose how to handle the additional values. + v = my_cookie_values[0] -The :py:attr:`~.Request.cookies` attribute is a regular -:py:class:`dict` object. The returned object should be treated as -read-only to avoid unintended side-effects. + # ... .. _setting-cookies: diff --git a/docs/changes/2.0.0.rst b/docs/changes/2.0.0.rst index b9f5c8977..60effcdaf 100644 --- a/docs/changes/2.0.0.rst +++ b/docs/changes/2.0.0.rst @@ -64,6 +64,9 @@ Breaking Changes stream when Falcon detects that it is running on the wsgiref server. If you need to normalize stream semantics between wsgiref and a production WSGI server, :attr:`~.Request.bounded_stream` may be used instead. +- :attr:`falcon.Request.cookies` now gives precedence to the first value + encountered in the Cookie header for a given cookie name, rather than the + last. Changes to Supported Platforms ------------------------------ @@ -120,6 +123,12 @@ New & Improved ``dumps()`` and ``loads()`` functions. This enables support not only for using any of a number of third-party JSON libraries, but also for customizing the keyword arguments used when (de)serializing objects. +- Added a new method, :meth:`~.Request.get_cookie_values`, to the + :class:`~.Request` class. The new method supports getting all values + provided for a given cookie, and is now the preferred mechanism for + reading request cookies. +- Optimized request cookie parsing. It is now roughly an order of magnitude + faster. - :meth:`~.Response.append_header` now supports appending raw Set-Cookie header values. Fixed diff --git a/falcon/request.py b/falcon/request.py index c3a69ed16..4e6ae7636 100644 --- a/falcon/request.py +++ b/falcon/request.py @@ -27,11 +27,6 @@ from falcon.util.uri import parse_host, parse_query_string from falcon.vendor import mimeparse -# NOTE(tbug): In some cases, compat.http_cookies is not a module -# but a dict-like structure. This fixes that issue. -# See issue https://github.com/falconry/falcon/issues/556 -SimpleCookie = compat.http_cookies.SimpleCookie - DEFAULT_ERROR_LOG_FORMAT = (u'{0:%Y-%m-%d %H:%M:%S} [FALCON] [ERROR]' u' {1} {2}{3} => ') @@ -256,8 +251,12 @@ class Request(object): client_accepts_xml (bool): ``True`` if the Accept header indicates that the client is willing to receive XML, otherwise ``False``. cookies (dict): - A dict of name/value cookie pairs. (See also: - :ref:`Getting Cookies <getting-cookies>`) + A dict of name/value cookie pairs. The returned object should be + treated as read-only to avoid unintended side-effects. + If a cookie appears more than once in the request, only the first + value encountered will be made available here. + + See also: :meth:`~get_cookie_values` content_type (str): Value of the Content-Type header, or ``None`` if the header is missing. content_length (int): Value of the Content-Length header converted @@ -394,7 +393,6 @@ class Request(object): '_cached_prefix', '_cached_relative_uri', '_cached_uri', - '_cookies', '_params', '_wsgierrors', 'content_type', @@ -409,6 +407,9 @@ class Request(object): '_media', ) + _cookies = None + _cookies_collapsed = None + # Child classes may override this context_type = type('RequestContext', (dict,), {}) @@ -456,8 +457,6 @@ def __init__(self, env, options=None): else: self._params = {} - self._cookies = None - self._cached_access_route = None self._cached_forwarded = None self._cached_forwarded_prefix = None @@ -825,24 +824,17 @@ def params(self): @property def cookies(self): - if self._cookies is None: - # NOTE(tbug): We might want to look into parsing - # cookies ourselves. The SimpleCookie is doing a - # lot if stuff only required to SEND cookies. - cookie_header = self.get_header('Cookie', default='') - parser = SimpleCookie() - for cookie_part in cookie_header.split('; '): - try: - parser.load(cookie_part) - except compat.http_cookies.CookieError: - pass - cookies = {} - for morsel in parser.values(): - cookies[morsel.key] = morsel.value + if self._cookies_collapsed is None: + if self._cookies is None: + header_value = self.get_header('Cookie') + if header_value: + self._cookies = helpers.parse_cookie_header(header_value) + else: + self._cookies = {} - self._cookies = cookies + self._cookies_collapsed = {n: v[0] for n, v in self._cookies.items()} - return self._cookies + return self._cookies_collapsed @property def access_route(self): @@ -1077,6 +1069,37 @@ def get_header_as_datetime(self, header, required=False, obs_date=False): 'Section 7.1.1.1') raise errors.HTTPInvalidHeader(msg, header) + def get_cookie_values(self, name): + """Return all values provided in the Cookie header for the named cookie. + + (See also: :ref:`Getting Cookies <getting-cookies>`) + + Args: + name (str): Cookie name, case-sensitive. + + Returns: + list: Ordered list of all values specified in the Cookie header for + the named cookie, or ``None`` if the cookie was not included in + the request. If the cookie is specified more than once in the + header, the returned list of values will preserve the ordering of + the individual ``cookie-pair``'s in the header. + """ + + if self._cookies is None: + # PERF(kgriffs): While this code isn't exactly DRY (the same code + # is duplicated by the cookies property) it does make things a bit + # more performant by removing the extra function call that would + # be required to factor this out. If we ever have to do this in a + # *third* place, we would probably want to factor it out at that + # point. + header_value = self.get_header('Cookie') + if header_value: + self._cookies = helpers.parse_cookie_header(header_value) + else: + self._cookies = {} + + return self._cookies.get(name) + def get_param(self, name, required=False, store=None, default=None): """Return the raw value of a query string parameter as a string. diff --git a/falcon/request_helpers.py b/falcon/request_helpers.py index 13b9a1e1b..421b20e99 100644 --- a/falcon/request_helpers.py +++ b/falcon/request_helpers.py @@ -15,6 +15,78 @@ """Utilities for the Request class.""" import io +import re + +from falcon.util.compat import http_cookies + +# https://tools.ietf.org/html/rfc6265#section-4.1.1 +# +# NOTE(kgriffs): Fortunately we don't have to worry about code points in +# header strings outside the range 0x0000 - 0x00FF per PEP 3333 +# (see also: https://www.python.org/dev/peps/pep-3333/#unicode-issues) +# +_COOKIE_NAME_RESERVED_CHARS = re.compile('[\x00-\x1F\x7F-\xFF()<>@,;:\\\\"/[\\]?={} \x09]') + + +def parse_cookie_header(header_value): + """Parse a Cookie header value into a dict of named values. + + (See also: RFC 6265, Section 5.4) + + Args: + header_value (str): Value of a Cookie header + + Returns: + dict: Map of cookie names to a list of all cookie values found in the + header for that name. If a cookie is specified more than once in the + header, the order of the values will be preserved. + """ + + # See also: + # + # https://tools.ietf.org/html/rfc6265#section-5.4 + # https://tools.ietf.org/html/rfc6265#section-4.1.1 + # + + cookies = {} + + for token in header_value.split(';'): + name, __, value = token.partition('=') + + # NOTE(kgriffs): RFC6265 is more strict about whitespace, but we + # are more lenient here to better handle old user agents and to + # mirror Python's standard library cookie parsing behavior + name = name.strip() + value = value.strip() + + # NOTE(kgriffs): Skip malformed cookie-pair + if not name: + continue + + # NOTE(kgriffs): Skip cookies with invalid names + if _COOKIE_NAME_RESERVED_CHARS.search(name): + continue + + # NOTE(kgriffs): To maximize compatibility, we mimic the support in the + # standard library for escaped characters within a double-quoted + # cookie value according to the obsolete RFC 2109. However, we do not + # expect to see this encoding used much in practice, since Base64 is + # the current de-facto standard, as recommended by RFC 6265. + # + # PERF(kgriffs): These checks have been hoisted from within _unquote() + # to avoid the extra function call in the majority of the cases when it + # is not needed. + if len(value) > 2 and value[0] == '"' and value[-1] == '"': + value = http_cookies._unquote(value) + + # PERF(kgriffs): This is slightly more performant as + # compared to using dict.setdefault() + if name in cookies: + cookies[name].append(value) + else: + cookies[name] = [value] + + return cookies def header_property(wsgi_name):

diff --git a/tests/test_cookies.py b/tests/test_cookies.py index 9d34b461e..e0cbfcf90 100644 --- a/tests/test_cookies.py +++ b/tests/test_cookies.py @@ -241,7 +241,9 @@ def test_request_cookie_parsing(): 'Cookie', """ logged_in=no;_gh_sess=eyJzZXXzaW9uX2lkIjoiN2; - tz=Europe/Berlin; _ga=GA1.2.332347814.1422308165; + tz=Europe/Berlin; _ga =GA1.2.332347814.1422308165; + tz2=Europe/Paris ; _ga2="line1\\012line2"; + tz3=Europe/Madrid ;_ga3= GA3.2.332347814.1422308165; _gat=1; _octo=GH1.1.201722077.1422308165 """ @@ -251,39 +253,75 @@ def test_request_cookie_parsing(): environ = testing.create_environ(headers=headers) req = falcon.Request(environ) - assert req.cookies['logged_in'] == 'no' - assert req.cookies['tz'] == 'Europe/Berlin' - assert req.cookies['_octo'] == 'GH1.1.201722077.1422308165' - - assert 'logged_in' in req.cookies - assert '_gh_sess' in req.cookies - assert 'tz' in req.cookies - assert '_ga' in req.cookies - assert '_gat' in req.cookies - assert '_octo' in req.cookies + # NOTE(kgriffs): Test case-sensitivity + assert req.get_cookie_values('TZ') is None + assert 'TZ' not in req.cookies + with pytest.raises(KeyError): + req.cookies['TZ'] + + for name, value in [ + ('logged_in', 'no'), + ('_gh_sess', 'eyJzZXXzaW9uX2lkIjoiN2'), + ('tz', 'Europe/Berlin'), + ('tz2', 'Europe/Paris'), + ('tz3', 'Europe/Madrid'), + ('_ga', 'GA1.2.332347814.1422308165'), + ('_ga2', 'line1\nline2'), + ('_ga3', 'GA3.2.332347814.1422308165'), + ('_gat', '1'), + ('_octo', 'GH1.1.201722077.1422308165'), + ]: + assert name in req.cookies + assert req.cookies[name] == value + assert req.get_cookie_values(name) == [value] def test_invalid_cookies_are_ignored(): + vals = [chr(i) for i in range(0x1F)] + vals += [chr(i) for i in range(0x7F, 0xFF)] + vals += '()<>@,;:\\"/[]?={} \x09'.split() + + for c in vals: + headers = [ + ( + 'Cookie', + 'good_cookie=foo;bad' + c + 'cookie=bar' + ), + ] + + environ = testing.create_environ(headers=headers) + req = falcon.Request(environ) + + assert req.cookies['good_cookie'] == 'foo' + assert 'bad' + c + 'cookie' not in req.cookies + + +def test_duplicate_cookie(): headers = [ ( 'Cookie', - """ - good_cookie=foo; - bad{cookie=bar - """ + 'x=1;bad{cookie=bar; x=2;x=3 ; x=4;' ), ] environ = testing.create_environ(headers=headers) req = falcon.Request(environ) - assert req.cookies['good_cookie'] == 'foo' - assert 'bad{cookie' not in req.cookies + assert req.cookies['x'] == '1' + assert req.get_cookie_values('x') == ['1', '2', '3', '4'] def test_cookie_header_is_missing(): environ = testing.create_environ(headers={}) + + req = falcon.Request(environ) + assert req.cookies == {} + assert req.get_cookie_values('x') is None + + # NOTE(kgriffs): Test again with a new object to cover calling in the + # opposite order. req = falcon.Request(environ) + assert req.get_cookie_values('x') is None assert req.cookies == {}

diff --git a/CHANGES.rst b/CHANGES.rst index bf705ab82..54c3a289a 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -61,6 +61,9 @@ Breaking Changes Falcon detects that it is running on the wsgiref server. If you need to normalize stream semantics between wsgiref and a production WSGI server, ``Request.bounded_stream`` may be used instead. +- ``Request.cookies`` now gives precedence to the first value + encountered in the Cookie header for a given cookie name, rather than the + last. Changes to Supported Platforms ------------------------------ @@ -109,6 +112,11 @@ New & Improved ``dumps()`` and ``loads()`` functions. This enables support not only for using any of a number of third-party JSON libraries, but also for customizing the keyword arguments used when (de)serializing objects. +- Added a new method, ``get_cookie_values()``, to the ``Request`` + class. The new method supports getting all values provided for a given + cookie, and is now the preferred mechanism for reading request cookies. +- Optimized request cookie parsing. It is now roughly an order of magnitude + faster. - ``append_header()`` now supports appending raw Set-Cookie header values. Fixed diff --git a/docs/api/cookies.rst b/docs/api/cookies.rst index dbfc918bf..828780c08 100644 --- a/docs/api/cookies.rst +++ b/docs/api/cookies.rst @@ -3,15 +3,16 @@ Cookies ------- -Cookie support is available in Falcon version 0.3 or later. - .. _getting-cookies: Getting Cookies ~~~~~~~~~~~~~~~ -Cookies can be read from a request via the :py:attr:`~.Request.cookies` -request attribute: +Cookies can be read from a request either via the +:py:meth:`~.Request.get_cookie_values` method or the :py:attr:`~.Request.cookies` +attribute on the :py:class:`~.Request` object. Generally speaking, the +:py:meth:`~.Request.get_cookie_values` method should be used unless you need a +collection of all the cookies in the request. .. code:: python @@ -20,13 +21,13 @@ request attribute: cookies = req.cookies - if 'my_cookie' in cookies: - my_cookie_value = cookies['my_cookie'] - # .... + my_cookie_values = req.get_cookie_values('my_cookie') + if my_cookie_values: + # NOTE: If there are multiple values set for the cookie, you + # will need to choose how to handle the additional values. + v = my_cookie_values[0] -The :py:attr:`~.Request.cookies` attribute is a regular -:py:class:`dict` object. The returned object should be treated as -read-only to avoid unintended side-effects. + # ... .. _setting-cookies: diff --git a/docs/changes/2.0.0.rst b/docs/changes/2.0.0.rst index b9f5c8977..60effcdaf 100644 --- a/docs/changes/2.0.0.rst +++ b/docs/changes/2.0.0.rst @@ -64,6 +64,9 @@ Breaking Changes stream when Falcon detects that it is running on the wsgiref server. If you need to normalize stream semantics between wsgiref and a production WSGI server, :attr:`~.Request.bounded_stream` may be used instead. +- :attr:`falcon.Request.cookies` now gives precedence to the first value + encountered in the Cookie header for a given cookie name, rather than the + last. Changes to Supported Platforms ------------------------------ @@ -120,6 +123,12 @@ New & Improved ``dumps()`` and ``loads()`` functions. This enables support not only for using any of a number of third-party JSON libraries, but also for customizing the keyword arguments used when (de)serializing objects. +- Added a new method, :meth:`~.Request.get_cookie_values`, to the + :class:`~.Request` class. The new method supports getting all values + provided for a given cookie, and is now the preferred mechanism for + reading request cookies. +- Optimized request cookie parsing. It is now roughly an order of magnitude + faster. - :meth:`~.Response.append_header` now supports appending raw Set-Cookie header values. Fixed

[ { "components": [ { "doc": "Return all values provided in the Cookie header for the named cookie.\n\n(See also: :ref:`Getting Cookies <getting-cookies>`)\n\nArgs:\n name (str): Cookie name, case-sensitive.\n\nReturns:\n list: Ordered list of all values specified in the Cookie header for\n ...

[ "tests/test_cookies.py::test_request_cookie_parsing", "tests/test_cookies.py::test_invalid_cookies_are_ignored", "tests/test_cookies.py::test_duplicate_cookie", "tests/test_cookies.py::test_cookie_header_is_missing" ]

[ "tests/test_cookies.py::test_response_base_case", "tests/test_cookies.py::test_response_disable_secure_globally", "tests/test_cookies.py::test_response_complex_case", "tests/test_cookies.py::test_cookie_expires_naive", "tests/test_cookies.py::test_cookie_expires_aware", "tests/test_cookies.py::test_cookie...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> feat(Request): Improve request cookie handling This patch provides support for getting all values for a given cookie (when the same cookie is included multiple times in the request), and also optimizes request cookie parsing to make it an order of magnitude faster. BREAKING CHANGE: Request.cookies now gives precedence to the first value encountered in the Cookie header for a given cookie name, rather than the last. BREAKING CHANGE: Request cookie parsing no longer uses the standard library for most of the parsing logic. This may lead to subtley different results for archaic cookie header formats, since the new implementation is based on the latest RFC 6265. Closes #1107 Closes #1046 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in falcon/request.py] (definition of Request.get_cookie_values:) def get_cookie_values(self, name): """Return all values provided in the Cookie header for the named cookie. (See also: :ref:`Getting Cookies <getting-cookies>`) Args: name (str): Cookie name, case-sensitive. Returns: list: Ordered list of all values specified in the Cookie header for the named cookie, or ``None`` if the cookie was not included in the request. If the cookie is specified more than once in the header, the returned list of values will preserve the ordering of the individual ``cookie-pair``'s in the header.""" [end of new definitions in falcon/request.py] [start of new definitions in falcon/request_helpers.py] (definition of parse_cookie_header:) def parse_cookie_header(header_value): """Parse a Cookie header value into a dict of named values. (See also: RFC 6265, Section 5.4) Args: header_value (str): Value of a Cookie header Returns: dict: Map of cookie names to a list of all cookie values found in the header for that name. If a cookie is specified more than once in the header, the order of the values will be preserved.""" [end of new definitions in falcon/request_helpers.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Multiple cookies with same name in request returns only one This looks like it could be relatively simple fix, but it would involve changing the cookie API a bit. If my browser has two cookies set using the same name - let's call this `_csrf` for example - they are both sent to the server. This is the string returned by `req.get_header("Cookie")`: ``` _csrf=2HBpry7fn6OBCIdS2SnFI-jCdQcq3bt0m03gWgCtjRA; _csrf=Oq_o_Lo_dhhDXqZHQ95NhBp8Nvzntx1FUG-2ryAi6nA ``` However, only one of these is made available in `req.cookies`. It would be preferable to have a method of getting both of these cookies somehow. ---------- We could potentially add a new method, `get_cookie_values()` to handle this case. How else might this be designed? Happy to take suggestions. Thanks for submitting this Gareth, I think this is a helpful request and I appreciate you taking the time to submit it as an issue. I don't think this is something that should be supported as I think it breaks that key-value nature of HTTP Cookies. While the [HTTP cookie spec](https://tools.ietf.org/html/rfc6265#section-5.4) does not prohibit it explicitly, it does use the term `set` which, in a mathematical sense are distinct or unique objects. By adding support for multiple values for a given key, we are no longer working with a set- this would cause deviation from the spec and I do not believe is desirable. As you have mentioned, you can get the raw value for the `Cookie` header by accessing `req.headers` directly. To expand on this a bit, by default Werkzueg (the wsgi layer for Flask) uses `MultiDict`'s base class https://github.com/pallets/werkzeug/blob/e378a8f83d7549904abd7ae5b7ac53491a3c76cf/werkzeug/http.py#L997 which is interesting because the feature is there to support the functionality you are requesting (`MultiDict`) however Flask does not use it. Here is an example flask app which generates the same result as Falcon (the last value in the cookie header for that key). ```python3 import flask app = flask.Flask(__name__) @app.route('/') def index(): print(flask.request.cookies) return '', 200 if __name__ == '__main__': app.run() ``` When I run this HTTP request: ```http GET / HTTP/1.1 Cookie: _csrf=2HBpry7fn6OBCIdS2SnFI-jCdQcq3bt0m03gWgCtjRA; _csrf=Oq_o_Lo_dhhDXqZHQ95NhBp8Nvzntx1FUG-2ryAi6nA Host: localhost:5000 Connection: close User-Agent: Paw/3.1.5 (Macintosh; OS X/10.13.4) GCDHTTPRequest ``` Flask prints `{'_csrf': 'Oq_o_Lo_dhhDXqZHQ95NhBp8Nvzntx1FUG-2ryAi6nA'}` which means it is taking the second value, that seems to be more appropriate behavior and what Falcon is using. What's the consensus on this issue? I agree that it goes against best practice but it could still be helpful for some use cases. I could work on it this weekend but I'll defer to you guys on whether or not it should be adopted. This is an interesting part of [RFC 6265 - 4.2.2](https://tools.ietf.org/html/rfc6265#section-4.2.2): > Although cookies are serialized linearly in the Cookie header, servers SHOULD NOT rely upon the serialization order. In particular, if the Cookie header contains two cookies with the same name (e.g., that were set with different Path or Domain attributes), servers SHOULD NOT rely upon the order in which these cookies appear in the header. However, it does not seem to mention which cookie should take precedence when two are set with the same name. The one with a more specific path? I think in the case given above there is no obvious choice, and therefore it is incorrect usage. I think the answer is still that ONE has to take precedence. It seems falcon chooses based on whatever was added last, which based on the above spec could be interpreted as incorrect; although it does say SHOULD NOT. 😉 Some solutions to the above answer: - There are two csrf tokens, rename them to be more specific `csrf_form1` `csrf_form2` - Concatenate the tokens somehow and encode them in Base64. This is a note from the spec about servers, but could apply to the above issue as well I think. > To maximize compatibility with user agents, servers that wish to store arbitrary data in a cookie-value SHOULD encode that data, for example, using Base64 [RFC4648]. In summary, if we should change anything I think it should be how we determine cookie precedence. -------------------- </issues>

77d5e6394a88ead151c9469494749f95f06b24bf

scikit-learn__scikit-learn-13146

13,146

scikit-learn/scikit-learn

0.22

c0c53137cec61a4d6cd72d8a43bbe0321476e440

2019-02-12T16:33:12Z

diff --git a/doc/inspection.rst b/doc/inspection.rst index 745539d51bf77..b53aeb436b4cd 100644 --- a/doc/inspection.rst +++ b/doc/inspection.rst @@ -5,6 +5,19 @@ Inspection ---------- +Predictive performance is often the main goal of developing machine learning +models. Yet summarising performance with an evaluation metric is often +insufficient: it assumes that the evaluation metric and test dataset +perfectly reflect the target domain, which is rarely true. In certain domains, +a model needs a certain level of interpretability before it can be deployed. +A model that is exhibiting performance issues needs to be debugged for one to +understand the model's underlying issue. The +:mod:`sklearn.inspection` module provides tools to help understand the +predictions from a model and what affects them. This can be used to +evaluate assumptions and biases of a model, design a better model, or +to diagnose issues with model performance. + .. toctree:: modules/partial_dependence + modules/permutation_importance diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index d9c87362e5a11..30fc3b5102bc6 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -657,6 +657,7 @@ Kernels: :template: function.rst inspection.partial_dependence + inspection.permutation_importance inspection.plot_partial_dependence @@ -1257,7 +1258,6 @@ Model validation pipeline.make_pipeline pipeline.make_union - .. _preprocessing_ref: :mod:`sklearn.preprocessing`: Preprocessing and Normalization diff --git a/doc/modules/permutation_importance.rst b/doc/modules/permutation_importance.rst new file mode 100644 index 0000000000000..d1f850ffeb793 --- /dev/null +++ b/doc/modules/permutation_importance.rst @@ -0,0 +1,69 @@ + +.. _permutation_importance: + +Permutation feature importance +============================== + +.. currentmodule:: sklearn.inspection + +Permutation feature importance is a model inspection technique that can be used +for any `fitted` `estimator` when the data is rectangular. This is especially +useful for non-linear or opaque `estimators`. The permutation feature +importance is defined to be the decrease in a model score when a single feature +value is randomly shuffled [1]_. This procedure breaks the relationship between +the feature and the target, thus the drop in the model score is indicative of +how much the model depends on the feature. This technique benefits from being +model agnostic and can be calculated many times with different permutations of +the feature. + +The :func:`permutation_importance` function calculates the feature importance +of `estimators` for a given dataset. The ``n_repeats`` parameter sets the number +of times a feature is randomly shuffled and returns a sample of feature +importances. Permutation importances can either be computed on the training set +or an held-out testing or validation set. Using a held-out set makes it +possible to highlight which features contribute the most to the generalization +power of the inspected model. Features that are important on the training set +but not on the held-out set might cause the model to overfit. + +Note that features that are deemed non-important for some model with a +low predictive performance could be highly predictive for a model that +generalizes better. The conclusions should always be drawn in the context of +the specific model under inspection and cannot be automatically generalized to +the intrinsic predictive value of the features by them-selves. Therefore it is +always important to evaluate the predictive power of a model using a held-out +set (or better with cross-validation) prior to computing importances. + +Relation to impurity-based importance in trees +---------------------------------------------- + +Tree based models provides a different measure of feature importances based +on the mean decrease in impurity (MDI, the splitting criterion). This gives +importance to features that may not be predictive on unseen data. The +permutation feature importance avoids this issue, since it can be applied to +unseen data. Furthermore, impurity-based feature importance for trees +are strongly biased and favor high cardinality features +(typically numerical features). Permutation-based feature importances do not +exhibit such a bias. Additionally, the permutation feature importance may use +an arbitrary metric on the tree's predictions. These two methods of obtaining +feature importance are explored in: +:ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance.py`. + +Strongly correlated features +---------------------------- + +When two features are correlated and one of the features is permuted, the model +will still have access to the feature through its correlated feature. This will +result in a lower importance for both features, where they might *actually* be +important. One way to handle this is to cluster features that are correlated +and only keep one feature from each cluster. This use case is explored in: +:ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance_multicollinear.py`. + +.. topic:: Examples: + + * :ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance.py` + * :ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance_multicollinear.py` + +.. topic:: References: + + .. [1] L. Breiman, "Random Forests", Machine Learning, 45(1), 5-32, + 2001. https://doi.org/10.1023/A:1010933404324 diff --git a/examples/inspection/plot_permutation_importance.py b/examples/inspection/plot_permutation_importance.py new file mode 100644 index 0000000000000..c449573821a96 --- /dev/null +++ b/examples/inspection/plot_permutation_importance.py @@ -0,0 +1,177 @@ +""" +================================================================ +Permutation Importance vs Random Forest Feature Importance (MDI) +================================================================ + +In this example, we will compare the impurity-based feature importance of +:class:`~sklearn.ensemble.RandomForestClassifier` with the +permutation importance on the titanic dataset using +:func:`~sklearn.inspection.permutation_importance`. We will show that the +impurity-based feature importance can inflate the importance of numerical +features. + +Furthermore, the impurity-based feature importance of random forests suffers +from being computed on statistics derived from the training dataset: the +importances can be high even for features that are not predictive of the target +variable, as long as the model has the capacity to use them to overfit. + +This example shows how to use Permutation Importances as an alternative that +can mitigate those limitations. + +.. topic:: References: + + .. [1] L. Breiman, "Random Forests", Machine Learning, 45(1), 5-32, + 2001. https://doi.org/10.1023/A:1010933404324 +""" +print(__doc__) +import matplotlib.pyplot as plt +import numpy as np + +from sklearn.datasets import fetch_openml +from sklearn.ensemble import RandomForestClassifier +from sklearn.impute import SimpleImputer +from sklearn.inspection import permutation_importance +from sklearn.compose import ColumnTransformer +from sklearn.model_selection import train_test_split +from sklearn.pipeline import Pipeline +from sklearn.preprocessing import OneHotEncoder + + +############################################################################## +# Data Loading and Feature Engineering +# ------------------------------------ +# Let's use pandas to load a copy of the titanic dataset. The following shows +# how to apply separate preprocessing on numerical and categorical features. +# +# We further include two random variables that are not correlated in any way +# with the target variable (``survived``): +# +# - ``random_num`` is a high cardinality numerical variable (as many unique +# values as records). +# - ``random_cat`` is a low cardinality categorical variable (3 possible +# values). +X, y = fetch_openml("titanic", version=1, as_frame=True, return_X_y=True) +X['random_cat'] = np.random.randint(3, size=X.shape[0]) +X['random_num'] = np.random.randn(X.shape[0]) + +categorical_columns = ['pclass', 'sex', 'embarked', 'random_cat'] +numerical_columns = ['age', 'sibsp', 'parch', 'fare', 'random_num'] + +X = X[categorical_columns + numerical_columns] + +X_train, X_test, y_train, y_test = train_test_split( + X, y, stratify=y, random_state=42) + +categorical_pipe = Pipeline([ + ('imputer', SimpleImputer(strategy='constant', fill_value='missing')), + ('onehot', OneHotEncoder(handle_unknown='ignore')) +]) +numerical_pipe = Pipeline([ + ('imputer', SimpleImputer(strategy='mean')) +]) + +preprocessing = ColumnTransformer( + [('cat', categorical_pipe, categorical_columns), + ('num', numerical_pipe, numerical_columns)]) + +rf = Pipeline([ + ('preprocess', preprocessing), + ('classifier', RandomForestClassifier(random_state=42)) +]) +rf.fit(X_train, y_train) + +############################################################################## +# Accuracy of the Model +# --------------------- +# Prior to inspecting the feature importances, it is important to check that +# the model predictive performance is high enough. Indeed there would be little +# interest of inspecting the important features of a non-predictive model. +# +# Here one can observe that the train accuracy is very high (the forest model +# has enough capacity to completely memorize the training set) but it can still +# generalize well enough to the test set thanks to the built-in bagging of +# random forests. +# +# It might be possible to trade some accuracy on the training set for a +# slightly better accuracy on the test set by limiting the capacity of the +# trees (for instance by setting ``min_samples_leaf=5`` or +# ``min_samples_leaf=10``) so as to limit overfitting while not introducing too +# much underfitting. +# +# However let's keep our high capacity random forest model for now so as to +# illustrate some pitfalls with feature importance on variables with many +# unique values. +print("RF train accuracy: %0.3f" % rf.score(X_train, y_train)) +print("RF test accuracy: %0.3f" % rf.score(X_test, y_test)) + + +############################################################################## +# Tree's Feature Importance from Mean Decrease in Impurity (MDI) +# -------------------------------------------------------------- +# The impurity-based feature importance ranks the numerical features to be the +# most important features. As a result, the non-predictive ``random_num`` +# variable is ranked the most important! +# +# This problem stems from two limitations of impurity-based feature +# importances: +# +# - impurity-based importances are biased towards high cardinality features; +# - impurity-based importances are computed on training set statistics and +# therefore do not reflect the ability of feature to be useful to make +# predictions that generalize to the test set (when the model has enough +# capacity). +ohe = (rf.named_steps['preprocess'] + .named_transformers_['cat'] + .named_steps['onehot']) +feature_names = ohe.get_feature_names(input_features=categorical_columns) +feature_names = np.r_[feature_names, numerical_columns] + +tree_feature_importances = ( + rf.named_steps['classifier'].feature_importances_) +sorted_idx = tree_feature_importances.argsort() + +y_ticks = np.arange(0, len(feature_names)) +fig, ax = plt.subplots() +ax.barh(y_ticks, tree_feature_importances[sorted_idx]) +ax.set_yticklabels(feature_names[sorted_idx]) +ax.set_yticks(y_ticks) +ax.set_title("Random Forest Feature Importances (MDI)") +fig.tight_layout() +plt.show() + + +############################################################################## +# As an alternative, the permutation importances of ``rf`` are computed on a +# held out test set. This shows that the low cardinality categorical feature, +# ``sex`` is the most important feature. +# +# Also note that both random features have very low importances (close to 0) as +# expected. +result = permutation_importance(rf, X_test, y_test, n_repeats=10, + random_state=42, n_jobs=2) +sorted_idx = result.importances_mean.argsort() + +fig, ax = plt.subplots() +ax.boxplot(result.importances[sorted_idx].T, + vert=False, labels=X_test.columns[sorted_idx]) +ax.set_title("Permutation Importances (test set)") +fig.tight_layout() +plt.show() + +############################################################################## +# It is also possible to compute the permutation importances on the training +# set. This reveals that ``random_num`` gets a significantly higher importance +# ranking than when computed on the test set. The difference between those two +# plots is a confirmation that the RF model has enough capacity to use that +# random numerical feature to overfit. You can further confirm this by +# re-running this example with constrained RF with min_samples_leaf=10. +result = permutation_importance(rf, X_train, y_train, n_repeats=10, + random_state=42, n_jobs=2) +sorted_idx = result.importances_mean.argsort() + +fig, ax = plt.subplots() +ax.boxplot(result.importances[sorted_idx].T, + vert=False, labels=X_train.columns[sorted_idx]) +ax.set_title("Permutation Importances (train set)") +fig.tight_layout() +plt.show() diff --git a/examples/inspection/plot_permutation_importance_multicollinear.py b/examples/inspection/plot_permutation_importance_multicollinear.py new file mode 100644 index 0000000000000..460de614ed3b2 --- /dev/null +++ b/examples/inspection/plot_permutation_importance_multicollinear.py @@ -0,0 +1,111 @@ +""" +================================================================= +Permutation Importance with Multicollinear or Correlated Features +================================================================= + +In this example, we compute the permutation importance on the Wisconsin +breast cancer dataset using :func:`~sklearn.inspection.permutation_importance`. +The :class:`~sklearn.ensemble.RandomForestClassifier` can easily get about 97% +accuracy on a test dataset. Because this dataset contains multicollinear +features, the permutation importance will show that none of the features are +important. One approach to handling multicollinearity is by performing +hierarchical clustering on the features' Spearman rank-order correlations, +picking a threshold, and keeping a single feature from each cluster. + +.. note:: + See also + :ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance.py` +""" +print(__doc__) +from collections import defaultdict + +import matplotlib.pyplot as plt +import numpy as np +from scipy.stats import spearmanr +from scipy.cluster import hierarchy + +from sklearn.datasets import load_breast_cancer +from sklearn.ensemble import RandomForestClassifier +from sklearn.inspection import permutation_importance +from sklearn.model_selection import train_test_split + +############################################################################## +# Random Forest Feature Importance on Breast Cancer Data +# ------------------------------------------------------ +# First, we train a random forest on the breast cancer dataset and evaluate +# its accuracy on a test set: +data = load_breast_cancer() +X, y = data.data, data.target +X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42) + +clf = RandomForestClassifier(n_estimators=100, random_state=42) +clf.fit(X_train, y_train) +print("Accuracy on test data: {:.2f}".format(clf.score(X_test, y_test))) + +############################################################################## +# Next, we plot the tree based feature importance and the permutation +# importance. The permutation importance plot shows that permuting a feature +# drops the accuracy by at most `0.012`, which would suggest that none of the +# features are important. This is in contradiction with the high test accuracy +# computed above: some feature must be important. The permutation importance +# is calculated on the training set to show how much the model relies on each +# feature during training. +result = permutation_importance(clf, X_train, y_train, n_repeats=10, + random_state=42) +perm_sorted_idx = result.importances_mean.argsort() + +tree_importance_sorted_idx = np.argsort(clf.feature_importances_) +tree_indicies = np.arange(1, len(clf.feature_importances_) + 1) + +fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 8)) +ax1.barh(tree_indicies, clf.feature_importances_[tree_importance_sorted_idx]) +ax1.set_yticklabels(data.feature_names) +ax1.set_yticks(tree_indicies) +ax2.boxplot(result.importances[perm_sorted_idx].T, vert=False, + labels=data.feature_names) +fig.tight_layout() +plt.show() + +############################################################################## +# Handling Multicollinear Features +# -------------------------------- +# When features are collinear, permutating one feature will have little +# effect on the models performance because it can get the same information +# from a correlated feature. One way to handle multicollinear features is by +# performing hierarchical clustering on the Spearman rank-order correlations, +# picking a threshold, and keeping a single feature from each cluster. First, +# we plot a heatmap of the correlated features: +fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 8)) +corr = spearmanr(X).correlation +corr_linkage = hierarchy.ward(corr) +dendro = hierarchy.dendrogram(corr_linkage, labels=data.feature_names, ax=ax1, + leaf_rotation=90) +dendro_idx = np.arange(0, len(dendro['ivl'])) + +ax2.imshow(corr[dendro['leaves'], :][:, dendro['leaves']]) +ax2.set_xticks(dendro_idx) +ax2.set_yticks(dendro_idx) +ax2.set_xticklabels(dendro['ivl'], rotation='vertical') +ax2.set_yticklabels(dendro['ivl']) +fig.tight_layout() +plt.show() + +############################################################################## +# Next, we manually pick a threshold by visual inspection of the dendrogram +# to group our features into clusters and choose a feature from each cluster to +# keep, select those features from our dataset, and train a new random forest. +# The test accuracy of the new random forest did not change much compared to +# the random forest trained on the complete dataset. +cluster_ids = hierarchy.fcluster(corr_linkage, 1, criterion='distance') +cluster_id_to_feature_ids = defaultdict(list) +for idx, cluster_id in enumerate(cluster_ids): + cluster_id_to_feature_ids[cluster_id].append(idx) +selected_features = [v[0] for v in cluster_id_to_feature_ids.values()] + +X_train_sel = X_train[:, selected_features] +X_test_sel = X_test[:, selected_features] + +clf_sel = RandomForestClassifier(n_estimators=100, random_state=42) +clf_sel.fit(X_train_sel, y_train) +print("Accuracy on test data with features removed: {:.2f}".format( + clf_sel.score(X_test_sel, y_test))) diff --git a/sklearn/inspection/__init__.py b/sklearn/inspection/__init__.py index 2bf3fe14c0023..6670e4c576c4d 100644 --- a/sklearn/inspection/__init__.py +++ b/sklearn/inspection/__init__.py @@ -1,9 +1,10 @@ """The :mod:`sklearn.inspection` module includes tools for model inspection.""" from .partial_dependence import partial_dependence from .partial_dependence import plot_partial_dependence - +from .permutation_importance import permutation_importance __all__ = [ 'partial_dependence', 'plot_partial_dependence', + 'permutation_importance' ] diff --git a/sklearn/inspection/permutation_importance.py b/sklearn/inspection/permutation_importance.py new file mode 100644 index 0000000000000..8f63a6c000a36 --- /dev/null +++ b/sklearn/inspection/permutation_importance.py @@ -0,0 +1,126 @@ +"""Permutation importance for estimators""" +import numpy as np +from joblib import Parallel +from joblib import delayed + +from ..metrics import check_scoring +from ..utils import check_random_state +from ..utils import check_array +from ..utils import Bunch + + +def _safe_column_setting(X, col_idx, values): + """Set column on X using `col_idx`""" + if hasattr(X, "iloc"): + X.iloc[:, col_idx] = values + else: + X[:, col_idx] = values + + +def _safe_column_indexing(X, col_idx): + """Return column from X using `col_idx`""" + if hasattr(X, "iloc"): + return X.iloc[:, col_idx].values + else: + return X[:, col_idx] + + +def _calculate_permutation_scores(estimator, X, y, col_idx, random_state, + n_repeats, scorer): + """Calculate score when `col_idx` is permuted.""" + original_feature = _safe_column_indexing(X, col_idx).copy() + temp = original_feature.copy() + + scores = np.zeros(n_repeats) + for n_round in range(n_repeats): + random_state.shuffle(temp) + _safe_column_setting(X, col_idx, temp) + feature_score = scorer(estimator, X, y) + scores[n_round] = feature_score + + _safe_column_setting(X, col_idx, original_feature) + return scores + + +def permutation_importance(estimator, X, y, scoring=None, n_repeats=5, + n_jobs=None, random_state=None): + """Permutation importance for feature evaluation [BRE]_. + + The `estimator` is required to be a fitted estimator. `X` can be the + data set used to train the estimator or a hold-out set. The permutation + importance of a feature is calculated as follows. First, a baseline metric, + defined by `scoring`, is evaluated on a (potentially different) dataset + defined by the `X`. Next, a feature column from the validation set is + permuted and the metric is evaluated again. The permutation importance is + defined to be the difference between the baseline metric and metric from + permutating the feature column. + + Read more in the :ref:`User Guide <permutation_importance>`. + + Parameters + ---------- + estimator : object + An estimator that has already been `fitted` and is compatible with + `scorer`. + + X : ndarray or DataFrame, shape (n_samples, n_features) + Data on which permutation importance will be computed. + + y : array-like or None, shape (n_samples, ) or (n_samples, n_classes) + Targets for supervised or `None` for unsupervised. + + scoring : string, callable or None, default=None + Scorer to use. It can be a single + string (see :ref:`scoring_parameter`) or a callable (see + :ref:`scoring`). If None, the estimator's default scorer is used. + + n_repeats : int, default=5 + Number of times to permute a feature. + + n_jobs : int or None, default=None + The number of jobs to use for the computation. + `None` means 1 unless in a :obj:`joblib.parallel_backend` context. + `-1` means using all processors. See :term:`Glossary <n_jobs>` + for more details. + + random_state : int, RandomState instance, or None, default=None + Pseudo-random number generator to control the permutations of each + feature. See :term:`random_state`. + + Returns + ------- + result : Bunch + Dictionary-like object, with attributes: + + importances_mean : ndarray, shape (n_features, ) + Mean of feature importance over `n_repeats`. + importances_std : ndarray, shape (n_features, ) + Standard deviation over `n_repeats`. + importances : ndarray, shape (n_features, n_repeats) + Raw permutation importance scores. + + References + ---------- + .. [BRE] L. Breiman, "Random Forests", Machine Learning, 45(1), 5-32, + 2001. https://doi.org/10.1023/A:1010933404324 + """ + if hasattr(X, "iloc"): + X = X.copy() # Dataframe + else: + X = check_array(X, force_all_finite='allow-nan', dtype=np.object, + copy=True) + + random_state = check_random_state(random_state) + scorer = check_scoring(estimator, scoring=scoring) + + baseline_score = scorer(estimator, X, y) + scores = np.zeros((X.shape[1], n_repeats)) + + scores = Parallel(n_jobs=n_jobs)(delayed(_calculate_permutation_scores)( + estimator, X, y, col_idx, random_state, n_repeats, scorer + ) for col_idx in range(X.shape[1])) + + importances = baseline_score - np.array(scores) + return Bunch(importances_mean=np.mean(importances, axis=1), + importances_std=np.std(importances, axis=1), + importances=importances)

diff --git a/sklearn/inspection/tests/test_permutation_importance.py b/sklearn/inspection/tests/test_permutation_importance.py new file mode 100644 index 0000000000000..9394202cfce97 --- /dev/null +++ b/sklearn/inspection/tests/test_permutation_importance.py @@ -0,0 +1,154 @@ +import pytest +import numpy as np + +from numpy.testing import assert_allclose + +from sklearn.compose import ColumnTransformer +from sklearn.datasets import load_boston +from sklearn.datasets import load_iris +from sklearn.datasets import make_regression +from sklearn.ensemble import RandomForestRegressor +from sklearn.ensemble import RandomForestClassifier +from sklearn.linear_model import LinearRegression +from sklearn.linear_model import LogisticRegression +from sklearn.impute import SimpleImputer +from sklearn.inspection import permutation_importance +from sklearn.pipeline import make_pipeline +from sklearn.preprocessing import OneHotEncoder +from sklearn.preprocessing import StandardScaler +from sklearn.preprocessing import scale + + +@pytest.mark.parametrize("n_jobs", [1, 2]) +def test_permutation_importance_correlated_feature_regression(n_jobs): + # Make sure that feature highly correlated to the target have a higher + # importance + rng = np.random.RandomState(42) + n_repeats = 5 + + dataset = load_boston() + X, y = dataset.data, dataset.target + y_with_little_noise = ( + y + rng.normal(scale=0.001, size=y.shape[0])).reshape(-1, 1) + + X = np.hstack([X, y_with_little_noise]) + + clf = RandomForestRegressor(n_estimators=10, random_state=42) + clf.fit(X, y) + + result = permutation_importance(clf, X, y, n_repeats=n_repeats, + random_state=rng, n_jobs=n_jobs) + + assert result.importances.shape == (X.shape[1], n_repeats) + + # the correlated feature with y was added as the last column and should + # have the highest importance + assert np.all(result.importances_mean[-1] > + result.importances_mean[:-1]) + + +@pytest.mark.parametrize("n_jobs", [1, 2]) +def test_permutation_importance_correlated_feature_regression_pandas(n_jobs): + pd = pytest.importorskip("pandas") + + # Make sure that feature highly correlated to the target have a higher + # importance + rng = np.random.RandomState(42) + n_repeats = 5 + + dataset = load_iris() + X, y = dataset.data, dataset.target + y_with_little_noise = ( + y + rng.normal(scale=0.001, size=y.shape[0])).reshape(-1, 1) + + # Adds feature correlated with y as the last column + X = pd.DataFrame(X, columns=dataset.feature_names) + X['correlated_feature'] = y_with_little_noise + + clf = RandomForestClassifier(n_estimators=10, random_state=42) + clf.fit(X, y) + + result = permutation_importance(clf, X, y, n_repeats=n_repeats, + random_state=rng, n_jobs=n_jobs) + + assert result.importances.shape == (X.shape[1], n_repeats) + + # the correlated feature with y was added as the last column and should + # have the highest importance + assert np.all(result.importances_mean[-1] > result.importances_mean[:-1]) + + +def test_permutation_importance_mixed_types(): + rng = np.random.RandomState(42) + n_repeats = 4 + + # Last column is correlated with y + X = np.array([[1.0, 2.0, 3.0, np.nan], [2, 1, 2, 1]]).T + y = np.array([0, 1, 0, 1]) + + clf = make_pipeline(SimpleImputer(), LogisticRegression(solver='lbfgs')) + clf.fit(X, y) + result = permutation_importance(clf, X, y, n_repeats=n_repeats, + random_state=rng) + + assert result.importances.shape == (X.shape[1], n_repeats) + + # the correlated feature with y is the last column and should + # have the highest importance + assert np.all(result.importances_mean[-1] > result.importances_mean[:-1]) + + # use another random state + rng = np.random.RandomState(0) + result2 = permutation_importance(clf, X, y, n_repeats=n_repeats, + random_state=rng) + assert result2.importances.shape == (X.shape[1], n_repeats) + + assert not np.allclose(result.importances, result2.importances) + + # the correlated feature with y is the last column and should + # have the highest importance + assert np.all(result2.importances_mean[-1] > result2.importances_mean[:-1]) + + +def test_permutation_importance_mixed_types_pandas(): + pd = pytest.importorskip("pandas") + rng = np.random.RandomState(42) + n_repeats = 5 + + # Last column is correlated with y + X = pd.DataFrame({'col1': [1.0, 2.0, 3.0, np.nan], + 'col2': ['a', 'b', 'a', 'b']}) + y = np.array([0, 1, 0, 1]) + + num_preprocess = make_pipeline(SimpleImputer(), StandardScaler()) + preprocess = ColumnTransformer([ + ('num', num_preprocess, ['col1']), + ('cat', OneHotEncoder(), ['col2']) + ]) + clf = make_pipeline(preprocess, LogisticRegression(solver='lbfgs')) + clf.fit(X, y) + + result = permutation_importance(clf, X, y, n_repeats=n_repeats, + random_state=rng) + + assert result.importances.shape == (X.shape[1], n_repeats) + # the correlated feature with y is the last column and should + # have the highest importance + assert np.all(result.importances_mean[-1] > result.importances_mean[:-1]) + + +def test_permutation_importance_linear_regresssion(): + X, y = make_regression(n_samples=500, n_features=10, random_state=0) + + X = scale(X) + y = scale(y) + + lr = LinearRegression().fit(X, y) + + # this relationship can be computed in closed form + expected_importances = 2 * lr.coef_**2 + results = permutation_importance(lr, X, y, + n_repeats=50, + scoring='neg_mean_squared_error') + assert_allclose(expected_importances, results.importances_mean, + rtol=1e-1, atol=1e-6)

diff --git a/doc/inspection.rst b/doc/inspection.rst index 745539d51bf77..b53aeb436b4cd 100644 --- a/doc/inspection.rst +++ b/doc/inspection.rst @@ -5,6 +5,19 @@ Inspection ---------- +Predictive performance is often the main goal of developing machine learning +models. Yet summarising performance with an evaluation metric is often +insufficient: it assumes that the evaluation metric and test dataset +perfectly reflect the target domain, which is rarely true. In certain domains, +a model needs a certain level of interpretability before it can be deployed. +A model that is exhibiting performance issues needs to be debugged for one to +understand the model's underlying issue. The +:mod:`sklearn.inspection` module provides tools to help understand the +predictions from a model and what affects them. This can be used to +evaluate assumptions and biases of a model, design a better model, or +to diagnose issues with model performance. + .. toctree:: modules/partial_dependence + modules/permutation_importance diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index d9c87362e5a11..30fc3b5102bc6 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -657,6 +657,7 @@ Kernels: :template: function.rst inspection.partial_dependence + inspection.permutation_importance inspection.plot_partial_dependence @@ -1257,7 +1258,6 @@ Model validation pipeline.make_pipeline pipeline.make_union - .. _preprocessing_ref: :mod:`sklearn.preprocessing`: Preprocessing and Normalization diff --git a/doc/modules/permutation_importance.rst b/doc/modules/permutation_importance.rst new file mode 100644 index 0000000000000..d1f850ffeb793 --- /dev/null +++ b/doc/modules/permutation_importance.rst @@ -0,0 +1,69 @@ + +.. _permutation_importance: + +Permutation feature importance +============================== + +.. currentmodule:: sklearn.inspection + +Permutation feature importance is a model inspection technique that can be used +for any `fitted` `estimator` when the data is rectangular. This is especially +useful for non-linear or opaque `estimators`. The permutation feature +importance is defined to be the decrease in a model score when a single feature +value is randomly shuffled [1]_. This procedure breaks the relationship between +the feature and the target, thus the drop in the model score is indicative of +how much the model depends on the feature. This technique benefits from being +model agnostic and can be calculated many times with different permutations of +the feature. + +The :func:`permutation_importance` function calculates the feature importance +of `estimators` for a given dataset. The ``n_repeats`` parameter sets the number +of times a feature is randomly shuffled and returns a sample of feature +importances. Permutation importances can either be computed on the training set +or an held-out testing or validation set. Using a held-out set makes it +possible to highlight which features contribute the most to the generalization +power of the inspected model. Features that are important on the training set +but not on the held-out set might cause the model to overfit. + +Note that features that are deemed non-important for some model with a +low predictive performance could be highly predictive for a model that +generalizes better. The conclusions should always be drawn in the context of +the specific model under inspection and cannot be automatically generalized to +the intrinsic predictive value of the features by them-selves. Therefore it is +always important to evaluate the predictive power of a model using a held-out +set (or better with cross-validation) prior to computing importances. + +Relation to impurity-based importance in trees +---------------------------------------------- + +Tree based models provides a different measure of feature importances based +on the mean decrease in impurity (MDI, the splitting criterion). This gives +importance to features that may not be predictive on unseen data. The +permutation feature importance avoids this issue, since it can be applied to +unseen data. Furthermore, impurity-based feature importance for trees +are strongly biased and favor high cardinality features +(typically numerical features). Permutation-based feature importances do not +exhibit such a bias. Additionally, the permutation feature importance may use +an arbitrary metric on the tree's predictions. These two methods of obtaining +feature importance are explored in: +:ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance.py`. + +Strongly correlated features +---------------------------- + +When two features are correlated and one of the features is permuted, the model +will still have access to the feature through its correlated feature. This will +result in a lower importance for both features, where they might *actually* be +important. One way to handle this is to cluster features that are correlated +and only keep one feature from each cluster. This use case is explored in: +:ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance_multicollinear.py`. + +.. topic:: Examples: + + * :ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance.py` + * :ref:`sphx_glr_auto_examples_inspection_plot_permutation_importance_multicollinear.py` + +.. topic:: References: + + .. [1] L. Breiman, "Random Forests", Machine Learning, 45(1), 5-32, + 2001. https://doi.org/10.1023/A:1010933404324

[ { "components": [ { "doc": "Set column on X using `col_idx`", "lines": [ 12, 17 ], "name": "_safe_column_setting", "signature": "def _safe_column_setting(X, col_idx, values):", "type": "function" }, { "doc": "Return co...

[ "sklearn/inspection/tests/test_permutation_importance.py::test_permutation_importance_correlated_feature_regression[1]", "sklearn/inspection/tests/test_permutation_importance.py::test_permutation_importance_correlated_feature_regression[2]", "sklearn/inspection/tests/test_permutation_importance.py::test_permuta...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG] Adds Permutation Importance  #### Reference Issues/PRs  Resolves https://github.com/scikit-learn/scikit-learn/issues/11187 #### What does this implement/fix? Explain your changes. Adds permutation importance to a `model_inspection` module. #### TODO - [x] Initial implementation. - [x] Add example demonstrating the differences between permutation importance and `feature_importances_` when using trees. - [x] Add to user guide. - [x] Support pandas dataframes.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/inspection/permutation_importance.py] (definition of _safe_column_setting:) def _safe_column_setting(X, col_idx, values): """Set column on X using `col_idx`""" (definition of _safe_column_indexing:) def _safe_column_indexing(X, col_idx): """Return column from X using `col_idx`""" (definition of _calculate_permutation_scores:) def _calculate_permutation_scores(estimator, X, y, col_idx, random_state, n_repeats, scorer): """Calculate score when `col_idx` is permuted.""" (definition of permutation_importance:) def permutation_importance(estimator, X, y, scoring=None, n_repeats=5, n_jobs=None, random_state=None): """Permutation importance for feature evaluation [BRE]_. The `estimator` is required to be a fitted estimator. `X` can be the data set used to train the estimator or a hold-out set. The permutation importance of a feature is calculated as follows. First, a baseline metric, defined by `scoring`, is evaluated on a (potentially different) dataset defined by the `X`. Next, a feature column from the validation set is permuted and the metric is evaluated again. The permutation importance is defined to be the difference between the baseline metric and metric from permutating the feature column. Read more in the :ref:`User Guide <permutation_importance>`. Parameters ---------- estimator : object An estimator that has already been `fitted` and is compatible with `scorer`. X : ndarray or DataFrame, shape (n_samples, n_features) Data on which permutation importance will be computed. y : array-like or None, shape (n_samples, ) or (n_samples, n_classes) Targets for supervised or `None` for unsupervised. scoring : string, callable or None, default=None Scorer to use. It can be a single string (see :ref:`scoring_parameter`) or a callable (see :ref:`scoring`). If None, the estimator's default scorer is used. n_repeats : int, default=5 Number of times to permute a feature. n_jobs : int or None, default=None The number of jobs to use for the computation. `None` means 1 unless in a :obj:`joblib.parallel_backend` context. `-1` means using all processors. See :term:`Glossary <n_jobs>` for more details. random_state : int, RandomState instance, or None, default=None Pseudo-random number generator to control the permutations of each feature. See :term:`random_state`. Returns ------- result : Bunch Dictionary-like object, with attributes: importances_mean : ndarray, shape (n_features, ) Mean of feature importance over `n_repeats`. importances_std : ndarray, shape (n_features, ) Standard deviation over `n_repeats`. importances : ndarray, shape (n_features, n_repeats) Raw permutation importance scores. References ---------- .. [BRE] L. Breiman, "Random Forests", Machine Learning, 45(1), 5-32, 2001. https://doi.org/10.1023/A:1010933404324""" [end of new definitions in sklearn/inspection/permutation_importance.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

c96e0958da46ebef482a4084cdda3285d5f5ad23

sympy__sympy-15924

15,924

sympy/sympy

1.4

27f2f10b965f912ea38bb189e6b498ec00efdb08

2019-02-04T15:54:08Z

diff --git a/sympy/core/relational.py b/sympy/core/relational.py index 45ff5a96f731..379789e59ca1 100644 --- a/sympy/core/relational.py +++ b/sympy/core/relational.py @@ -122,7 +122,39 @@ def reversed(self): """ ops = {Gt: Lt, Ge: Le, Lt: Gt, Le: Ge} a, b = self.args - return ops.get(self.func, self.func)(b, a, evaluate=False) + return Relational.__new__(ops.get(self.func, self.func), b, a) + + @property + def negated(self): + """Return the negated relationship. + + Examples + ======== + + >>> from sympy import Eq + >>> from sympy.abc import x + >>> Eq(x, 1) + Eq(x, 1) + >>> _.negated + Ne(x, 1) + >>> x < 1 + x < 1 + >>> _.negated + x >= 1 + + Notes + ===== + + This works more or less identical to ``~``/``Not``. The difference is + that ``negated`` returns the relationship even if `evaluate=False`. + Hence, this is useful in code when checking for e.g. negated relations + to exisiting ones as it will not be affected by the `evaluate` flag. + + """ + ops = {Eq: Ne, Ge: Lt, Gt: Le, Le: Gt, Lt: Ge, Ne: Eq} + # If there ever will be new Relational subclasses, the following line will work until it is properly sorted out + # return ops.get(self.func, lambda a, b, evaluate=False: ~(self.func(a, b, evaluate=evaluate)))(*self.args, evaluate=False) + return Relational.__new__(ops.get(self.func), *self.args) def _eval_evalf(self, prec): return self.func(*[s._evalf(prec) for s in self.args]) @@ -500,7 +532,7 @@ def __new__(cls, lhs, rhs, **options): if evaluate: is_equal = Equality(lhs, rhs) if isinstance(is_equal, BooleanAtom): - return ~is_equal + return is_equal.negated return Relational.__new__(cls, lhs, rhs, **options) @@ -524,7 +556,7 @@ def _eval_simplify(self, ratio, measure, rational, inverse): if isinstance(eq, Equality): # send back Ne with the new args return self.func(*eq.args) - return ~eq # result of Ne is ~Eq + return eq.negated # result of Ne is the negated Eq Ne = Unequality diff --git a/sympy/functions/elementary/piecewise.py b/sympy/functions/elementary/piecewise.py index 2e74b08975ac..1e0121a22e5a 100644 --- a/sympy/functions/elementary/piecewise.py +++ b/sympy/functions/elementary/piecewise.py @@ -267,12 +267,12 @@ def eval(cls, *_args): nonredundant = [] for c in cond.args: if (isinstance(c, Relational) and - (~c).canonical in current_cond): + c.negated.canonical in current_cond): continue nonredundant.append(c) cond = cond.func(*nonredundant) elif isinstance(cond, Relational): - if (~cond).canonical in current_cond: + if cond.negated.canonical in current_cond: cond = S.true current_cond.add(cond) diff --git a/sympy/logic/boolalg.py b/sympy/logic/boolalg.py index b0f64ec84156..8bbea2125c94 100644 --- a/sympy/logic/boolalg.py +++ b/sympy/logic/boolalg.py @@ -320,6 +320,10 @@ def __nonzero__(self): def __hash__(self): return hash(True) + @property + def negated(self): + return S.false + def as_set(self): """ Rewrite logic operators and relationals in terms of real sets. @@ -383,6 +387,10 @@ def __nonzero__(self): def __hash__(self): return hash(False) + @property + def negated(self): + return S.true + def as_set(self): """ Rewrite logic operators and relationals in terms of real sets. @@ -542,7 +550,7 @@ def _new_args_filter(cls, args): c = x.canonical if c in rel: continue - nc = (~c).canonical + nc = c.negated.canonical if any(r == nc for r in rel): return [S.false] rel.append(c) @@ -652,7 +660,7 @@ def _new_args_filter(cls, args): c = x.canonical if c in rel: continue - nc = (~c).canonical + nc = c.negated.canonical if any(r == nc for r in rel): return [S.true] rel.append(c) @@ -842,7 +850,7 @@ def __new__(cls, *args, **kwargs): argset.remove(arg) else: argset.add(arg) - rel = [(r, r.canonical, (~r).canonical) for r in argset if r.is_Relational] + rel = [(r, r.canonical, r.negated.canonical) for r in argset if r.is_Relational] odd = False # is number of complimentary pairs odd? start 0 -> False remove = [] for i, (r, c, nc) in enumerate(rel): @@ -1050,7 +1058,7 @@ def eval(cls, *args): elif A.is_Relational and B.is_Relational: if A.canonical == B.canonical: return S.true - if (~A).canonical == B.canonical: + if A.negated.canonical == B.canonical: return B else: return Basic.__new__(cls, *args) @@ -1093,7 +1101,7 @@ def __new__(cls, *args, **options): rel = [] for r in argset: if isinstance(r, Relational): - rel.append((r, r.canonical, (~r).canonical)) + rel.append((r, r.canonical, r.negated.canonical)) remove = [] for i, (r, c, nc) in enumerate(rel): for j in range(i + 1, len(rel)):

diff --git a/sympy/core/tests/test_relational.py b/sympy/core/tests/test_relational.py index 9c3d6c08d524..6b61c727f689 100644 --- a/sympy/core/tests/test_relational.py +++ b/sympy/core/tests/test_relational.py @@ -1,7 +1,7 @@ from sympy.utilities.pytest import XFAIL, raises from sympy import (S, Symbol, symbols, nan, oo, I, pi, Float, And, Or, Not, Implies, Xor, zoo, sqrt, Rational, simplify, Function, Eq, - log, cos, sin, Add) + log, cos, sin, Add, floor, ceiling) from sympy.core.compatibility import range from sympy.core.relational import (Relational, Equality, Unequality, GreaterThan, LessThan, StrictGreaterThan, @@ -658,17 +658,20 @@ def test_canonical(): @XFAIL -def test_issue_8444(): +def test_issue_8444_nonworkingtests(): x = symbols('x', real=True) assert (x <= oo) == (x >= -oo) == True x = symbols('x') assert x >= floor(x) assert (x < floor(x)) == False - assert Gt(x, floor(x)) == Gt(x, floor(x), evaluate=False) - assert Ge(x, floor(x)) == Ge(x, floor(x), evaluate=False) assert x <= ceiling(x) assert (x > ceiling(x)) == False + +def test_issue_8444_workingtests(): + x = symbols('x') + assert Gt(x, floor(x)) == Gt(x, floor(x), evaluate=False) + assert Ge(x, floor(x)) == Ge(x, floor(x), evaluate=False) assert Lt(x, ceiling(x)) == Lt(x, ceiling(x), evaluate=False) assert Le(x, ceiling(x)) == Le(x, ceiling(x), evaluate=False) i = symbols('i', integer=True) @@ -803,6 +806,21 @@ def test_Equality_rewrite_as_Add(): assert eq.rewrite(Add, evaluate=None).args == (x, x, y, -y) assert eq.rewrite(Add, evaluate=False).args == (x, y, x, -y) + def test_issue_15847(): a = Ne(x*(x+y), x**2 + x*y) assert simplify(a) == False + + +def test_negated_property(): + eq = Eq(x, y) + assert eq.negated == Ne(x, y) + + eq = Ne(x, y) + assert eq.negated == Eq(x, y) + + eq = Ge(x + y, y - x) + assert eq.negated == Lt(x + y, y - x) + + for f in (Eq, Ne, Ge, Gt, Le, Lt): + assert f(x, y).negated.negated == f(x, y) diff --git a/sympy/logic/tests/test_boolalg.py b/sympy/logic/tests/test_boolalg.py index d86e924d1ceb..6c737c3fcb6a 100644 --- a/sympy/logic/tests/test_boolalg.py +++ b/sympy/logic/tests/test_boolalg.py @@ -737,6 +737,11 @@ def test_canonical_atoms(): assert false.canonical == false +def test_negated_atoms(): + assert true.negated == false + assert false.negated == true + + def test_issue_8777(): assert And(x > 2, x < oo).as_set() == Interval(2, oo, left_open=True) assert And(x >= 1, x < oo).as_set() == Interval(1, oo)

[ { "components": [ { "doc": "Return the negated relationship.\n\nExamples\n========\n\n>>> from sympy import Eq\n>>> from sympy.abc import x\n>>> Eq(x, 1)\nEq(x, 1)\n>>> _.negated\nNe(x, 1)\n>>> x < 1\nx < 1\n>>> _.negated\nx >= 1\n\nNotes\n=====\n\nThis works more or less identical to ``~``/``Not`...

[ "test_negated_atoms" ]

[ "test_rel_ne", "test_rel_subs", "test_wrappers", "test_Eq", "test_rel_Infinity", "test_bool", "test_rich_cmp", "test_doit", "test_new_relational", "test_relational_bool_output", "test_relational_logic_symbols", "test_univariate_relational_as_set", "test_Not", "test_evaluate", "test_imagi...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added negated property to Relational and BooleanAtom  #### References to other Issues or PRs  Fixes #15869 #### Brief description of what is fixed or changed I have added a property `negated` to `Relational`s that returns the opposite Relational, so `Eq(x, y).negated` gives `Ne(x, y)`. This has only minor benefits over ~, one is that it ignores evaluate = False, so code that relies on negating a relation, primarily in `logic`, see #15869. The purpose of this code is to compare temporary expressions, so not to actually evaluate the expressions, so from that perspective it should be OK, just as the property `canonical` returns a slightly different expression, independent of evaluate. Hence, it should be used with a bit of care. I also added the property to `BooleanAtom` which makes sense because the result of a `Relational` is a `BooleanAtom`, but doesn't make sense as no other objects in `logic` has that property. From a coding perspective it is only used in a few places (at the moment, only checked quite few cases, could be more). #### Other comments Not sure if there should be a release note. I guess it can be convenient for the user to know about it sometimes. ~~I also believe that it is slightly faster than using Not as there should be more processing steps involved with Not. Not a major factor, but no drawback either.~~ Timeit tests show that this is < 10% slower. Not obvious why. Finally, I split the tests for #8444 as not all of them fails at the moment. Better to have those working is an executed test. Slightly unrelated, but better put it in here as I happened to see it now. Oh, yeah, I was thinking quite long before deciding on `negated`. One may imagine `inverted` or `complemented` as well. And probably a few more options. I know how to change it... #### Release Notes   * core * Relationals now have a property negated, which returns the opposite to the relation, similar to ~.  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/core/relational.py] (definition of Relational.negated:) def negated(self): """Return the negated relationship. Examples ======== >>> from sympy import Eq >>> from sympy.abc import x >>> Eq(x, 1) Eq(x, 1) >>> _.negated Ne(x, 1) >>> x < 1 x < 1 >>> _.negated x >= 1 Notes ===== This works more or less identical to ``~``/``Not``. The difference is that ``negated`` returns the relationship even if `evaluate=False`. Hence, this is useful in code when checking for e.g. negated relations to exisiting ones as it will not be affected by the `evaluate` flag.""" [end of new definitions in sympy/core/relational.py] [start of new definitions in sympy/logic/boolalg.py] (definition of BooleanTrue.negated:) def negated(self): (definition of BooleanFalse.negated:) def negated(self): [end of new definitions in sympy/logic/boolalg.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> Logic: Add `canonical` property to `Not` #### Brief description of what is fixed or changed The `_new_args_filter` for `And` and `Or` calls `(~c).canonical` explicitly, which cause `AttributeError`s because that property is not implemented. To trigger the error, try the following snippet: ``` from sympy import * a, b, c, d = symbols('a b c d') expr = (a > b) & (b > c) with evaluate(False): print(expr.xreplace({b: d})) ``` #### Other comments I'm not 100% that this is the preferred way to fix this, but it highlights the issue and contains one very simple solution. If there is a better way to prevent the given example from triggering an `AttributeError`, please let me know.  * logic * Added canonical property to Not  ---------- Thanks for your contribution. I'm not sure either, but agree that it seems to make sense. However, can you please add one or a few tests for this in https://github.com/sympy/sympy/blob/master/sympy/logic/tests/test_boolalg.py ? To make sure that the problem is not reintroduced later. The example you provided will be fine. Just add an assert with the correct answer. Plus possibly an explicit in `test_Not()` similar to: https://github.com/sympy/sympy/blob/2b4f967740cc56f864a2271c09215269a0983dd7/sympy/logic/tests/test_boolalg.py#L80 (Which of course raises the question about what the `canonical` property of `Not` actually should be, but clearly it would be good to have it defined, if possible.) @oscargus Thanks for the prompt reply. I've added two small tests, one that basically test the existence of the property `canonical` on `Not` objects and one that tests the behaviour of `Not(A > 1).canonical`. Please note that the second test would actually pass on `master`, since the simplification transforms `Not(A > 1)` into `A <= 1`, unless `evaluate(False)` is used, as in my previous example. However, this should now be caught by the `Not(A).canonical` test. You *do* need a test, just a modified one that tests the code you added. I'm not sure why you deleted the test completely. Will check back later. @smichr Apologies if I misunderstood you, but I had already added a test `assert Not(A).canonical == Not(A)` to this PR and _that test is still there_. I only added (and now removed) the `Not(e).canonical == Not(e)`, as I wanted to make sure that `Relational`s are covered - but as you rightly pointed out, `Not(A > 1)` will be immediately simplified to `A <= 1`, so that second test is not adding anything new. > if I misunderstood you OK, I see it now. What do you think about returning `self(getattr(self.args[0], 'canonical', self.args[0]))`? @smichr I tried it and got `TypeError: 'Not' object is not callable`. However, returning a new instance with `return Not(getattr(self.args[0], 'canonical', self.args[0]))` seems to work. Does that look alright to you? I left off the func: `return self.func(getattr(self.args[0], 'canonical', self.args[0]))`. This is preferred over returning Not since self may have been derived from Not (if I understand correctly...@asmeurer is the one that has pointed this out to me in the past). @smichr Oh yes, sorry. I forgot that this was the sympy way to re-initialize things (PR updated). Thanks for pointing this out and all your patience. I'm thinking that maybe it is better to add a property/method of `Relational` which simply negates the expression? `inverted`? `negated`? Basically remapping the logic operator to the opposite. A bit like `reversed`, but that actually invert it: https://github.com/sympy/sympy/blob/f472bcc07e8af4080d0e78057dd8beb948d8766f/sympy/core/relational.py#L105-L125 I'm not sure what happens if you apply your code to e.g. `And(x < 1, x >= 1)`, so ``` with evaluate(False): And(x < y, x >= y) ``` I think the purpose of the code is to detect this type of case. Maybe it still works (it evaluates to False without setting evaluate to False)? It seems like the code is maybe just applying a bit of "evaluation" when evaluate is false and that this is taken care of elsewhere when evaluate is true. Out of curiosity, how did you stumble upon the bug? > I'm thinking that maybe it is better I see what you mean: ``` >>> Not(And(x<0,y>1)) ~((y > 1) & (x < 0)) >>> simplify(Not(And(x<0,y>1))) ~((y > 1) & (x < 0)) ``` And rather than adding a canonical property to Not, perhaps it should be added to BooleanFunction to do what was done here on Not. Yes, there may be cases where that can help. When working on the recent PRs, especially #15912, it became quite clear how important it is to be able to express identically meaning expressions on an identical format. So improving #15899 is quite crucial in some cases. If one can extend that to BooleanFunction it would of course be even better, so `Nand(a, b)` and `Or(Not(a), Not(b))` can be identified as the same expressions. Not obvious how to define the requirements there though, but a start is probably to not use Nand, Nor or Nxor in the canonical format, but to apply de Morgan. So shall we commit what is here? Pros: this clarifies the need of a proper canonical for `BooleanFunction`s, the code is there and will solve a few issues Cons: will there be proper canonicals for boolean functions? The alternative as I see it is to add an `inverted` property as discussed above, That will solve all(?) usage in the code today (I've seen this at a few more places with the purpose of identifying the opposite relation so it should just be to replace `(~c).canonical` with `c.inverted.canonical`. At the moment I am more lending towards `inverted` as that does not mix `Boolean` and `Relational`. Although that mix seems quite natural from many aspects. Also, someone must write that property. > Cons: will there be proper canonicals for boolean functions? I think that is the best argument against this. If someone wants canonical relationals, they should make them so individually rather than asking the cotnaining expression to do so since (as you are saying) `canonical` might have meaning for the expression itself. On the otherhand, the invariant could be that `Expr.canonical` returns a canonical expression after making all arguments canonical. But we haven't made a SymPy-wide attribute implementing this idea. So I am in favor of closing this as a WontFix (yet) issue. -------------------- </issues>

e941ad69638189ea42507331e417b88837357dec

pydicom__pydicom-802

802

pydicom/pydicom

1.2

aa42809add6faa389937c846582a3d5196531376

2019-02-02T20:55:26Z

diff --git a/doc/whatsnew/v1.3.0.rst b/doc/whatsnew/v1.3.0.rst index 33b3cb4035..3cc1ac230b 100644 --- a/doc/whatsnew/v1.3.0.rst +++ b/doc/whatsnew/v1.3.0.rst @@ -10,10 +10,15 @@ Changes Use ``dataelem.DataElement.VM`` instead. * ``dataelem.isStringOrStringList`` and ``dataelem.isString`` functions are removed +* ``datadict.add_dict_entry`` and ``datadict.add_dict_entries`` now raise if + trying to add a private tag Enhancements ............ +* Added ``datadict.add_private_dict_entry`` and + ``datadict.add_private_dict_entries`` to add custom private tags + (:issue:`799`) * Added possibility to write into zip file using gzip (:issue:`753`) Fixes diff --git a/pydicom/datadict.py b/pydicom/datadict.py index 434168c3b6..751bac44a8 100644 --- a/pydicom/datadict.py +++ b/pydicom/datadict.py @@ -38,7 +38,7 @@ def add_dict_entry(tag, VR, keyword, description, VM='1', is_retired=''): Notes ---- - Dose not permanently update the dictionary, + Does not permanently update the dictionary, but only during run-time. Will replace an existing entry if the tag already exists in the dictionary. @@ -57,6 +57,11 @@ def add_dict_entry(tag, VR, keyword, description, VM='1', is_retired=''): Usually leave as blank string (default). Set to 'Retired' if is a retired data element. + Raises + ------ + ValueError + If the tag is a private tag. + See Also -------- pydicom.examples.add_dict_entry @@ -67,8 +72,8 @@ def add_dict_entry(tag, VR, keyword, description, VM='1', is_retired=''): Examples -------- >>> from pydicom import Dataset - >>> add_dict_entry(0x10011001, "UL", "TestOne", "Test One") - >>> add_dict_entry(0x10011002, "DS", "TestTwo", "Test Two", VM='3') + >>> add_dict_entry(0x10021001, "UL", "TestOne", "Test One") + >>> add_dict_entry(0x10021002, "DS", "TestTwo", "Test Two", VM='3') >>> ds = Dataset() >>> ds.TestOne = 'test' >>> ds.TestTwo = ['1', '2', '3'] @@ -79,7 +84,7 @@ def add_dict_entry(tag, VR, keyword, description, VM='1', is_retired=''): def add_dict_entries(new_entries_dict): - """Update pydicom's DICOM dictionary with new entries. + """Update pydicom's DICOM dictionary with new non-private entries. Parameters ---------- @@ -88,6 +93,11 @@ def add_dict_entries(new_entries_dict): {tag: (VR, VM, description, is_retired, keyword),...} where parameters are as described in add_dict_entry + Raises + ------ + ValueError + If one of the entries is a private tag. + See Also -------- add_dict_entry @@ -97,19 +107,24 @@ def add_dict_entries(new_entries_dict): -------- >>> from pydicom import Dataset >>> new_dict_items = { - ... 0x10011001: ('UL', '1', "Test One", '', 'TestOne'), - ... 0x10011002: ('DS', '3', "Test Two", '', 'TestTwo'), + ... 0x10021001: ('UL', '1', "Test One", '', 'TestOne'), + ... 0x10021002: ('DS', '3', "Test Two", '', 'TestTwo'), ... } >>> add_dict_entries(new_dict_items) >>> ds = Dataset() >>> ds.TestOne = 'test' >>> ds.TestTwo = ['1', '2', '3'] - >>> add_dict_entry(0x10011001, "UL", "TestOne", "Test One") + >>> add_dict_entry(0x10021001, "UL", "TestOne", "Test One") >>> ds = Dataset() >>> ds.TestOne = 'test' """ + if any([BaseTag(tag).is_private for tag in new_entries_dict]): + raise ValueError( + 'Private tags cannot be added using "add_dict_entries" - ' + 'use "add_private_dict_entries" instead') + # Update the dictionary itself DicomDictionary.update(new_entries_dict) @@ -119,6 +134,84 @@ def add_dict_entries(new_entries_dict): keyword_dict.update(new_names_dict) +def add_private_dict_entry(private_creator, tag, VR, description, VM='1'): + """Update pydicom's private DICOM tag dictionary with a new entry. + + Notes + ---- + Behaves like `add_dict_entry`, only for a private tag entry. + + Parameters + ---------- + private_creator : str + The private creator for the new entry. + tag : int + The tag number for the new dictionary entry. Note that the + 2 high bytes of the element part of the tag are ignored. + VR : str + DICOM value representation + description : str + The descriptive name used in printing the entry. + VM : str, optional + DICOM value multiplicity. If not specified, then '1' is used. + + Raises + ------ + ValueError + If the tag is a non-private tag. + + See Also + -------- + add_private_dict_entries + Update multiple values at once. + """ + new_dict_val = (VR, VM, description) + add_private_dict_entries(private_creator, {tag: new_dict_val}) + + +def add_private_dict_entries(private_creator, new_entries_dict): + """Update pydicom's private DICOM tag dictionary with new entries. + + Parameters + ---------- + private_creator: str + The private creator for all entries in new_entries_dict + new_entries_dict : dict + Dictionary of form: + {tag: (VR, VM, description),...} + where parameters are as described in add_private_dict_entry + + Raises + ------ + ValueError + If one of the entries is a non-private tag. + + See Also + -------- + add_private_dict_entry + Function to add a single entry to the private tag dictionary. + + Examples + -------- + >>> new_dict_items = { + ... 0x00410001: ('UL', '1', "Test One"), + ... 0x00410002: ('DS', '3', "Test Two", '3'), + ... } + >>> add_private_dict_entries("ACME LTD 1.2", new_dict_items) + >>> add_private_dict_entry("ACME LTD 1.3", 0x00410001, "US", "Test Three") + """ + + if not all([BaseTag(tag).is_private for tag in new_entries_dict]): + raise ValueError( + 'Non-private tags cannot be added using "add_private_dict_entries"' + ' - use "add_dict_entries" instead') + + new_entries = {'{:04x}xx{:02x}'.format(tag >> 16, tag & 0xff): value + for tag, value in new_entries_dict.items()} + private_dictionaries.setdefault( + private_creator, {}).update(new_entries) + + def get_entry(tag): """Return the tuple (VR, VM, name, is_retired, keyword) from the DICOM dictionary

diff --git a/pydicom/tests/test_dictionary.py b/pydicom/tests/test_dictionary.py index bbcec875c6..f575aaa278 100644 --- a/pydicom/tests/test_dictionary.py +++ b/pydicom/tests/test_dictionary.py @@ -1,81 +1,137 @@ # Copyright 2008-2018 pydicom authors. See LICENSE file for details. """Test for datadict.py""" -import unittest +import pytest + +from pydicom import DataElement from pydicom.dataset import Dataset from pydicom.datadict import (keyword_for_tag, dictionary_description, dictionary_has_tag, repeater_has_tag, repeater_has_keyword, get_private_entry, dictionary_VM, private_dictionary_VR, - private_dictionary_VM) + private_dictionary_VM, add_private_dict_entries, + add_private_dict_entry) from pydicom.datadict import add_dict_entry, add_dict_entries -class DictTests(unittest.TestCase): - def testTagNotFound(self): +class TestDict(object): + def test_tag_not_found(self): """dicom_dictionary: CleanName returns blank string for unknown tag""" - self.assertTrue(keyword_for_tag(0x99991111) == "") + assert '' == keyword_for_tag(0x99991111) - def testRepeaters(self): + def test_repeaters(self): """dicom_dictionary: Tags with "x" return correct dict info........""" - self.assertEqual(dictionary_description(0x280400), 'Transform Label') - self.assertEqual(dictionary_description(0x280410), - 'Rows For Nth Order Coefficients') + assert 'Transform Label' == dictionary_description(0x280400) + assert ('Rows For Nth Order Coefficients' == + dictionary_description(0x280410)) def test_dict_has_tag(self): """Test dictionary_has_tag""" - self.assertTrue(dictionary_has_tag(0x00100010)) - self.assertFalse(dictionary_has_tag(0x11110010)) + assert dictionary_has_tag(0x00100010) + assert not dictionary_has_tag(0x11110010) def test_repeater_has_tag(self): """Test repeater_has_tag""" - self.assertTrue(repeater_has_tag(0x60000010)) - self.assertTrue(repeater_has_tag(0x60020010)) - self.assertFalse(repeater_has_tag(0x00100010)) + assert repeater_has_tag(0x60000010) + assert repeater_has_tag(0x60020010) + assert not repeater_has_tag(0x00100010) def test_repeater_has_keyword(self): """Test repeater_has_keyword""" - self.assertTrue(repeater_has_keyword('OverlayData')) - self.assertFalse(repeater_has_keyword('PixelData')) + assert repeater_has_keyword('OverlayData') + assert not repeater_has_keyword('PixelData') def test_get_private_entry(self): """Test get_private_entry""" # existing entry entry = get_private_entry((0x0903, 0x0011), 'GEIIS PACS') - self.assertEqual('US', entry[0]) # VR - self.assertEqual('1', entry[1]) # VM - self.assertEqual('Significant Flag', entry[2]) # name - self.assertFalse(entry[3]) # is retired + assert 'US' == entry[0] # VR + assert '1' == entry[1] # VM + assert 'Significant Flag' == entry[2] # name + assert not entry[3] # is retired # existing entry in another slot entry = get_private_entry((0x0903, 0x1011), 'GEIIS PACS') - self.assertEqual('Significant Flag', entry[2]) # name + assert 'Significant Flag' == entry[2] # name # non-existing entry - self.assertRaises(KeyError, get_private_entry, - (0x0903, 0x0011), 'Nonexisting') - self.assertRaises(KeyError, get_private_entry, - (0x0903, 0x0091), 'GEIIS PACS') + with pytest.raises(KeyError): + get_private_entry((0x0903, 0x0011), 'Nonexisting') + with pytest.raises(KeyError): + get_private_entry((0x0903, 0x0091), 'GEIIS PACS') - def testAddEntry(self): + def test_add_entry(self): """dicom_dictionary: Can add and use a single dictionary entry""" - add_dict_entry(0x10011001, "UL", "TestOne", "Test One") - add_dict_entry(0x10011002, "DS", "TestTwo", "Test Two", VM='3') + add_dict_entry(0x10021001, "UL", "TestOne", "Test One") + add_dict_entry(0x10021002, "DS", "TestTwo", "Test Two", VM='3') ds = Dataset() ds.TestOne = 'test' ds.TestTwo = ['1', '2', '3'] - def testAddEntries(self): + def test_add_entry_raises_for_private_tag(self): + with pytest.raises(ValueError, + match='Private tags cannot be ' + 'added using "add_dict_entries"'): + add_dict_entry(0x10011101, 'DS', 'Test One', 'Test One') + + def test_add_entries(self): """dicom_dictionary: add and use a dict of new dictionary entries""" new_dict_items = { - 0x10011001: ('UL', '1', "Test One", '', 'TestOne'), - 0x10011002: ('DS', '3', "Test Two", '', 'TestTwo'), - } + 0x10021001: ('UL', '1', "Test One", '', 'TestOne'), + 0x10021002: ('DS', '3', "Test Two", '', 'TestTwo'), + } add_dict_entries(new_dict_items) ds = Dataset() ds.TestOne = 'test' ds.TestTwo = ['1', '2', '3'] + def test_add_entries_raises_for_private_tags(self): + new_dict_items = { + 0x10021001: ('UL', '1', 'Test One', '', 'TestOne'), + 0x10011002: ('DS', '3', 'Test Two', '', 'TestTwo'), + } + with pytest.raises(ValueError, match='Private tags cannot be added ' + 'using "add_dict_entries"'): + add_dict_entries(new_dict_items) + + def test_add_private_entry(self): + add_private_dict_entry('ACME 3.1', 0x10011101, 'DS', 'Test One', '3') + entry = get_private_entry((0x1001, 0x0001), 'ACME 3.1') + assert 'DS' == entry[0] # VR + assert '3' == entry[1] # VM + assert 'Test One' == entry[2] # description + + def test_add_private_entry_raises_for_non_private_tag(self): + with pytest.raises(ValueError, + match='Non-private tags cannot be ' + 'added using "add_private_dict_entries"'): + add_private_dict_entry('ACME 3.1', 0x10021101, 'DS', 'Test One') + + def test_add_private_entries(self): + """dicom_dictionary: add and use a dict of new dictionary entries""" + new_dict_items = { + 0x10011001: ('SH', '1', "Test One",), + 0x10011002: ('DS', '3', "Test Two", '', 'TestTwo'), + } + add_private_dict_entries('ACME 3.1', new_dict_items) + ds = Dataset() + ds[0x10010010] = DataElement(0x10010010, 'LO', 'ACME 3.1') + ds[0x10011001] = DataElement(0x10011001, 'SH', 'Test') + ds[0x10011002] = DataElement(0x10011002, 'DS', '1\\2\\3') + + assert 'Test' == ds[0x10011001].value + assert [1, 2, 3] == ds[0x10011002].value + + def test_add_private_entries_raises_for_non_private_tags(self): + new_dict_items = { + 0x10021001: ('UL', '1', 'Test One', '', 'TestOne'), + 0x10011002: ('DS', '3', 'Test Two', '', 'TestTwo'), + } + with pytest.raises(ValueError, + match='Non-private tags cannot be ' + 'added using "add_private_dict_entries"'): + add_private_dict_entries('ACME 3.1', new_dict_items) + def test_dictionary_VM(self): """Test dictionary_VM""" assert dictionary_VM(0x00000000) == '1' @@ -93,7 +149,3 @@ def test_private_dict_VR(self): def test_private_dict_VM(self): """Test private_dictionary_VM""" assert private_dictionary_VM(0x00090000, 'ACUSON') == '1' - - -if __name__ == "__main__": - unittest.main()

diff --git a/doc/whatsnew/v1.3.0.rst b/doc/whatsnew/v1.3.0.rst index 33b3cb4035..3cc1ac230b 100644 --- a/doc/whatsnew/v1.3.0.rst +++ b/doc/whatsnew/v1.3.0.rst @@ -10,10 +10,15 @@ Changes Use ``dataelem.DataElement.VM`` instead. * ``dataelem.isStringOrStringList`` and ``dataelem.isString`` functions are removed +* ``datadict.add_dict_entry`` and ``datadict.add_dict_entries`` now raise if + trying to add a private tag Enhancements ............ +* Added ``datadict.add_private_dict_entry`` and + ``datadict.add_private_dict_entries`` to add custom private tags + (:issue:`799`) * Added possibility to write into zip file using gzip (:issue:`753`) Fixes

[ { "components": [ { "doc": "Update pydicom's private DICOM tag dictionary with a new entry.\n\nNotes\n----\nBehaves like `add_dict_entry`, only for a private tag entry.\n\nParameters\n----------\nprivate_creator : str\n The private creator for the new entry.\ntag : int\n The tag number for t...

[ "pydicom/tests/test_dictionary.py::TestDict::test_tag_not_found", "pydicom/tests/test_dictionary.py::TestDict::test_repeaters", "pydicom/tests/test_dictionary.py::TestDict::test_dict_has_tag", "pydicom/tests/test_dictionary.py::TestDict::test_repeater_has_tag", "pydicom/tests/test_dictionary.py::TestDict::t...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG] Added possibility to add tags to the private dictionary - datadict.add_dict_entry and datadict.add_dict_entries now raise if trying to add a private tag - the new methods datadict.add_private_dict_entry/add_private_dict_entries likely raise if trying to add non-private entries - see #799  #### Reference Issue  #### What does this implement/fix? Explain your changes.  #### Any other comments?   ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in pydicom/datadict.py] (definition of add_private_dict_entry:) def add_private_dict_entry(private_creator, tag, VR, description, VM='1'): """Update pydicom's private DICOM tag dictionary with a new entry. Notes ---- Behaves like `add_dict_entry`, only for a private tag entry. Parameters ---------- private_creator : str The private creator for the new entry. tag : int The tag number for the new dictionary entry. Note that the 2 high bytes of the element part of the tag are ignored. VR : str DICOM value representation description : str The descriptive name used in printing the entry. VM : str, optional DICOM value multiplicity. If not specified, then '1' is used. Raises ------ ValueError If the tag is a non-private tag. See Also -------- add_private_dict_entries Update multiple values at once.""" (definition of add_private_dict_entries:) def add_private_dict_entries(private_creator, new_entries_dict): """Update pydicom's private DICOM tag dictionary with new entries. Parameters ---------- private_creator: str The private creator for all entries in new_entries_dict new_entries_dict : dict Dictionary of form: {tag: (VR, VM, description),...} where parameters are as described in add_private_dict_entry Raises ------ ValueError If one of the entries is a non-private tag. See Also -------- add_private_dict_entry Function to add a single entry to the private tag dictionary. Examples -------- >>> new_dict_items = { ... 0x00410001: ('UL', '1', "Test One"), ... 0x00410002: ('DS', '3', "Test Two", '3'), ... } >>> add_private_dict_entries("ACME LTD 1.2", new_dict_items) >>> add_private_dict_entry("ACME LTD 1.3", 0x00410001, "US", "Test Three")""" [end of new definitions in pydicom/datadict.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

3551f5b5a5f8d4de3ed92e5e479ac8c74a8c893a

sympy__sympy-15825

15,825

sympy/sympy

1.4

de3c43c77670a1430756e66d2d70975ee9c6affa

2019-01-22T15:38:51Z

diff --git a/sympy/crypto/__init__.py b/sympy/crypto/__init__.py index 757b33ab73b2..58ffb98e59e0 100644 --- a/sympy/crypto/__init__.py +++ b/sympy/crypto/__init__.py @@ -11,4 +11,4 @@ encipher_elgamal, dh_private_key, dh_public_key, dh_shared_key, padded_key, encipher_bifid, decipher_bifid, bifid_square, bifid5, bifid6, bifid10, decipher_gm, encipher_gm, gm_public_key, - gm_private_key) + gm_private_key, bg_private_key, bg_public_key, encipher_bg, decipher_bg) diff --git a/sympy/crypto/crypto.py b/sympy/crypto/crypto.py index a68dc35bdc71..a96957b4f046 100644 --- a/sympy/crypto/crypto.py +++ b/sympy/crypto/crypto.py @@ -28,7 +28,7 @@ from sympy.polys.polytools import gcd, Poly from sympy.utilities.misc import filldedent, translate from sympy.utilities.iterables import uniq -from sympy.utilities.randtest import _randrange +from sympy.utilities.randtest import _randrange, _randint def AZ(s=None): @@ -2246,3 +2246,172 @@ def decipher_gm(message, key): m <<= 1 m += not b return m + +################ Blum–Goldwasser cryptosystem ######################### + +def bg_private_key(p, q): + """ + Check if p and q can be used as private keys for + the Blum–Goldwasser cryptosystem. + + The three necessary checks for p and q to pass + so that they can be used as private keys: + + 1. p and q must both be prime + 2. p and q must be distinct + 3. p and q must be congruent to 3 mod 4 + + Parameters + ========== + + p, q : the keys to be checked + + Returns + ======= + + p, q : input values + + Raises + ====== + + ValueError : if p and q do not pass the above conditions + + """ + + if not isprime(p) or not isprime(q): + raise ValueError("the two arguments must be prime, " + "got %i and %i" %(p, q)) + elif p == q: + raise ValueError("the two arguments must be distinct, " + "got two copies of %i. " %p) + elif (p - 3) % 4 != 0 or (q - 3) % 4 != 0: + raise ValueError("the two arguments must be congruent to 3 mod 4, " + "got %i and %i" %(p, q)) + return p, q + +def bg_public_key(p, q): + """ + Calculates public keys from private keys. + + The function first checks the validity of + private keys passed as arguments and + then returns their product. + + Parameters + ========== + + p, q : the private keys + + Returns + ======= + + N : the public key + """ + p, q = bg_private_key(p, q) + N = p * q + return N + +def encipher_bg(i, key, seed=None): + """ + Encrypts the message using public key and seed. + + ALGORITHM: + 1. Encodes i as a string of L bits, m. + 2. Select a random element r, where 1 < r < key, and computes + x = r^2 mod key. + 3. Use BBS pseudo-random number generator to generate L random bits, b, + using the initial seed as x. + 4. Encrypted message, c_i = m_i XOR b_i, 1 <= i <= L. + 5. x_L = x^(2^L) mod key. + 6. Return (c, x_L) + + Parameters + ========== + + i : message, a non-negative integer + key : the public key + + Returns + ======= + + (encrypted_message, x_L) : Tuple + + Raises + ====== + + ValueError : if i is negative + """ + + if i < 0: + raise ValueError( + "message must be a non-negative " + "integer: got %d instead" % i) + + enc_msg = [] + while i > 0: + enc_msg.append(i % 2) + i //= 2 + enc_msg.reverse() + L = len(enc_msg) + + r = _randint(seed)(2, key - 1) + x = r**2 % key + x_L = pow(int(x), int(2**L), int(key)) + + rand_bits = [] + for k in range(L): + rand_bits.append(x % 2) + x = x**2 % key + + encrypt_msg = [m ^ b for (m, b) in zip(enc_msg, rand_bits)] + + return (encrypt_msg, x_L) + +def decipher_bg(message, key): + """ + Decrypts the message using private keys. + + ALGORITHM: + 1. Let, c be the encrypted message, y the second number received, + and p and q be the private keys. + 2. Compute, r_p = y^((p+1)/4 ^ L) mod p and + r_q = y^((q+1)/4 ^ L) mod q. + 3. Compute x_0 = (q(q^-1 mod p)r_p + p(p^-1 mod q)r_q) mod N. + 4. From, recompute the bits using the BBS generator, as in the + encryption algorithm. + 5. Compute original message by XORing c and b. + + Parameters + ========== + + message : Tuple of encrypted message and a non-negative integer. + key : Tuple of private keys + + Returns + ======= + + orig_msg : The original message + """ + + p, q = key + encrypt_msg, y = message + public_key = p * q + L = len(encrypt_msg) + p_t = ((p + 1)/4)**L + q_t = ((q + 1)/4)**L + r_p = pow(int(y), int(p_t), int(p)) + r_q = pow(int(y), int(q_t), int(q)) + + x = (q * mod_inverse(q, p) * r_p + p * mod_inverse(p, q) * r_q) % public_key + + orig_bits = [] + for k in range(L): + orig_bits.append(x % 2) + x = x**2 % public_key + + orig_msg = 0 + for (m, b) in zip(encrypt_msg, orig_bits): + orig_msg = orig_msg * 2 + orig_msg += (m ^ b) + + return orig_msg

diff --git a/sympy/crypto/tests/test_crypto.py b/sympy/crypto/tests/test_crypto.py index 80a0946f3670..24fb8a101d1e 100644 --- a/sympy/crypto/tests/test_crypto.py +++ b/sympy/crypto/tests/test_crypto.py @@ -13,7 +13,8 @@ encipher_elgamal, decipher_elgamal, dh_private_key, dh_public_key, dh_shared_key, decipher_shift, decipher_affine, encipher_bifid, decipher_bifid, bifid_square, padded_key, uniq, decipher_gm, - encipher_gm, gm_public_key, gm_private_key) + encipher_gm, gm_public_key, gm_private_key, encipher_bg, decipher_bg, + bg_private_key, bg_public_key) from sympy.matrices import Matrix from sympy.ntheory import isprime, is_primitive_root from sympy.polys.domains import FF @@ -335,3 +336,32 @@ def test_gm_public_key(): assert 323 == gm_public_key(17, 19)[1] assert 15 == gm_public_key(3, 5)[1] raises(ValueError, lambda: gm_public_key(15, 19)) + +def test_encipher_decipher_bg(): + ps = [67, 7, 71, 103, 11, 43, 107, 47, + 79, 19, 83, 23, 59, 127, 31] + qs = qs = [7, 71, 103, 11, 43, 107, 47, + 79, 19, 83, 23, 59, 127, 31, 67] + messages = [ + 0, 328, 343, 148, 1280, 758, 383, + 724, 603, 516, 766, 618, 186, + ] + + for p, q in zip(ps, qs): + pri = bg_private_key(p, q) + for msg in messages: + pub = bg_public_key(p, q) + enc = encipher_bg(msg, pub) + dec = decipher_bg(enc, pri) + assert dec == msg + +def test_bg_private_key(): + raises(ValueError, lambda: bg_private_key(8, 16)) + raises(ValueError, lambda: bg_private_key(8, 8)) + raises(ValueError, lambda: bg_private_key(13, 17)) + assert 23, 31 == bg_private_key(23, 31) + +def test_bg_public_key(): + assert 5293 == bg_public_key(67, 79) + assert 713 == bg_public_key(23, 31) + raises(ValueError, lambda: bg_private_key(13, 17))

[ { "components": [ { "doc": "Check if p and q can be used as private keys for\nthe Blum–Goldwasser cryptosystem.\n\nThe three necessary checks for p and q to pass\nso that they can be used as private keys:\n\n 1. p and q must both be prime\n 2. p and q must be distinct\n 3. p and q must be...

[ "test_cycle_list", "test_encipher_shift", "test_encipher_affine", "test_encipher_substitution", "test_check_and_join", "test_encipher_vigenere", "test_decipher_vigenere", "test_encipher_hill", "test_decipher_hill", "test_encipher_bifid5", "test_bifid5_square", "test_decipher_bifid5", "test_e...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Added Blum Goldwasser cryptosystem  #### References to other Issues or PRs https://en.wikipedia.org/wiki/Blum%E2%80%93Goldwasser_cryptosystem #### Brief description of what is fixed or changed bg_private_key, bg_public_key, encipher_bg have been added to sympy.crypto.crypto. These methods follow Blum–Goldwasser cryptosystem. #### Other comments Documentation and tests will be added soon #### Release Notes   * crypto * Added Blum Goldwasser cryptosystem  ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sympy/crypto/crypto.py] (definition of bg_private_key:) def bg_private_key(p, q): """Check if p and q can be used as private keys for the Blum–Goldwasser cryptosystem. The three necessary checks for p and q to pass so that they can be used as private keys: 1. p and q must both be prime 2. p and q must be distinct 3. p and q must be congruent to 3 mod 4 Parameters ========== p, q : the keys to be checked Returns ======= p, q : input values Raises ====== ValueError : if p and q do not pass the above conditions""" (definition of bg_public_key:) def bg_public_key(p, q): """Calculates public keys from private keys. The function first checks the validity of private keys passed as arguments and then returns their product. Parameters ========== p, q : the private keys Returns ======= N : the public key""" (definition of encipher_bg:) def encipher_bg(i, key, seed=None): """Encrypts the message using public key and seed. ALGORITHM: 1. Encodes i as a string of L bits, m. 2. Select a random element r, where 1 < r < key, and computes x = r^2 mod key. 3. Use BBS pseudo-random number generator to generate L random bits, b, using the initial seed as x. 4. Encrypted message, c_i = m_i XOR b_i, 1 <= i <= L. 5. x_L = x^(2^L) mod key. 6. Return (c, x_L) Parameters ========== i : message, a non-negative integer key : the public key Returns ======= (encrypted_message, x_L) : Tuple Raises ====== ValueError : if i is negative""" (definition of decipher_bg:) def decipher_bg(message, key): """Decrypts the message using private keys. ALGORITHM: 1. Let, c be the encrypted message, y the second number received, and p and q be the private keys. 2. Compute, r_p = y^((p+1)/4 ^ L) mod p and r_q = y^((q+1)/4 ^ L) mod q. 3. Compute x_0 = (q(q^-1 mod p)r_p + p(p^-1 mod q)r_q) mod N. 4. From, recompute the bits using the BBS generator, as in the encryption algorithm. 5. Compute original message by XORing c and b. Parameters ========== message : Tuple of encrypted message and a non-negative integer. key : Tuple of private keys Returns ======= orig_msg : The original message""" [end of new definitions in sympy/crypto/crypto.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

e941ad69638189ea42507331e417b88837357dec

scikit-learn__scikit-learn-13003

13,003

scikit-learn/scikit-learn

0.24

57bd85ed6a613028c2abb5e27dcf30263f0daa4b

2019-01-17T12:26:31Z

diff --git a/benchmarks/bench_plot_polynomial_kernel_approximation.py b/benchmarks/bench_plot_polynomial_kernel_approximation.py new file mode 100644 index 0000000000000..2b7556f37320e --- /dev/null +++ b/benchmarks/bench_plot_polynomial_kernel_approximation.py @@ -0,0 +1,156 @@ +""" +======================================================================== +Benchmark for explicit feature map approximation of polynomial kernels +======================================================================== + +An example illustrating the approximation of the feature map +of an Homogeneous Polynomial kernel. + +.. currentmodule:: sklearn.kernel_approximation + +It shows how to use :class:`PolynomialCountSketch` and :class:`Nystroem` to +approximate the feature map of a polynomial kernel for +classification with an SVM on the digits dataset. Results using a linear +SVM in the original space, a linear SVM using the approximate mappings +and a kernelized SVM are compared. + +The first plot shows the classification accuracy of Nystroem [2] and +PolynomialCountSketch [1] as the output dimension (n_components) grows. +It also shows the accuracy of a linear SVM and a polynomial kernel SVM +on the same data. + +The second plot explores the scalability of PolynomialCountSketch +and Nystroem. For a sufficiently large output dimension, +PolynomialCountSketch should be faster as it is O(n(d+klog k)) +while Nystroem is O(n(dk+k^2)). In addition, Nystroem requires +a time-consuming training phase, while training is almost immediate +for PolynomialCountSketch, whose training phase boils down to +initializing some random variables (because is data-independent). + +[1] Pham, N., & Pagh, R. (2013, August). Fast and scalable polynomial +kernels via explicit feature maps. In Proceedings of the 19th ACM SIGKDD +international conference on Knowledge discovery and data mining (pp. 239-247) +(http://chbrown.github.io/kdd-2013-usb/kdd/p239.pdf) + +[2] Charikar, M., Chen, K., & Farach-Colton, M. (2002, July). Finding frequent +items in data streams. In International Colloquium on Automata, Languages, and +Programming (pp. 693-703). Springer, Berlin, Heidelberg. +(http://www.vldb.org/pvldb/1/1454225.pdf) + +""" +# Author: Daniel Lopez-Sanchez <lope@usal.es> +# License: BSD 3 clause + +# Load data manipulation functions +from sklearn.datasets import load_digits +from sklearn.model_selection import train_test_split + +# Some common libraries +import matplotlib.pyplot as plt +import numpy as np + +# Will use this for timing results +from time import time + +# Import SVM classifiers and feature map approximation algorithms +from sklearn.svm import LinearSVC, SVC +from sklearn.kernel_approximation import Nystroem, PolynomialCountSketch +from sklearn.pipeline import Pipeline + +# Split data in train and test sets +X, y = load_digits()["data"], load_digits()["target"] +X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7) + +# Set the range of n_components for our experiments +out_dims = range(20, 400, 20) + +# Evaluate Linear SVM +lsvm = LinearSVC().fit(X_train, y_train) +lsvm_score = 100*lsvm.score(X_test, y_test) + +# Evaluate kernelized SVM +ksvm = SVC(kernel="poly", degree=2, gamma=1.).fit(X_train, y_train) +ksvm_score = 100*ksvm.score(X_test, y_test) + +# Evaluate PolynomialCountSketch + LinearSVM +ps_svm_scores = [] +n_runs = 5 + +# To compensate for the stochasticity of the method, we make n_tets runs +for k in out_dims: + score_avg = 0 + for _ in range(n_runs): + ps_svm = Pipeline([("PS", PolynomialCountSketch(degree=2, + n_components=k)), + ("SVM", LinearSVC())]) + score_avg += ps_svm.fit(X_train, y_train).score(X_test, y_test) + ps_svm_scores.append(100*score_avg/n_runs) + +# Evaluate Nystroem + LinearSVM +ny_svm_scores = [] +n_runs = 5 + +for k in out_dims: + score_avg = 0 + for _ in range(n_runs): + ny_svm = Pipeline([("NY", Nystroem(kernel="poly", gamma=1., degree=2, + coef0=0, n_components=k)), + ("SVM", LinearSVC())]) + score_avg += ny_svm.fit(X_train, y_train).score(X_test, y_test) + ny_svm_scores.append(100*score_avg/n_runs) + +# Show results +fig, ax = plt.subplots(figsize=(6, 4)) +ax.set_title("Accuracy results") +ax.plot(out_dims, ps_svm_scores, label="PolynomialCountSketch + linear SVM", + c="orange") +ax.plot(out_dims, ny_svm_scores, label="Nystroem + linear SVM", + c="blue") +ax.plot([out_dims[0], out_dims[-1]], [lsvm_score, lsvm_score], + label="Linear SVM", c="black", dashes=[2, 2]) +ax.plot([out_dims[0], out_dims[-1]], [ksvm_score, ksvm_score], + label="Poly-kernel SVM", c="red", dashes=[2, 2]) +ax.legend() +ax.set_xlabel("N_components for PolynomialCountSketch and Nystroem") +ax.set_ylabel("Accuracy (%)") +ax.set_xlim([out_dims[0], out_dims[-1]]) +fig.tight_layout() + +# Now lets evaluate the scalability of PolynomialCountSketch vs Nystroem +# First we generate some fake data with a lot of samples + +fakeData = np.random.randn(10000, 100) +fakeDataY = np.random.randint(0, high=10, size=(10000)) + +out_dims = range(500, 6000, 500) + +# Evaluate scalability of PolynomialCountSketch as n_components grows +ps_svm_times = [] +for k in out_dims: + ps = PolynomialCountSketch(degree=2, n_components=k) + + start = time() + ps.fit_transform(fakeData, None) + ps_svm_times.append(time() - start) + +# Evaluate scalability of Nystroem as n_components grows +# This can take a while due to the inefficient training phase +ny_svm_times = [] +for k in out_dims: + ny = Nystroem(kernel="poly", gamma=1., degree=2, coef0=0, n_components=k) + + start = time() + ny.fit_transform(fakeData, None) + ny_svm_times.append(time() - start) + +# Show results +fig, ax = plt.subplots(figsize=(6, 4)) +ax.set_title("Scalability results") +ax.plot(out_dims, ps_svm_times, label="PolynomialCountSketch", c="orange") +ax.plot(out_dims, ny_svm_times, label="Nystroem", c="blue") +ax.legend() +ax.set_xlabel("N_components for PolynomialCountSketch and Nystroem") +ax.set_ylabel("fit_transform time \n(s/10.000 samples)") +ax.set_xlim([out_dims[0], out_dims[-1]]) +fig.tight_layout() +plt.show() diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 2e54d000a13aa..70a5174629f37 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -706,6 +706,7 @@ Plotting kernel_approximation.AdditiveChi2Sampler kernel_approximation.Nystroem + kernel_approximation.PolynomialCountSketch kernel_approximation.RBFSampler kernel_approximation.SkewedChi2Sampler diff --git a/doc/modules/kernel_approximation.rst b/doc/modules/kernel_approximation.rst index fb3843c6bc045..4f5ee46a42057 100644 --- a/doc/modules/kernel_approximation.rst +++ b/doc/modules/kernel_approximation.rst @@ -149,6 +149,51 @@ above for the :class:`RBFSampler`. The only difference is in the free parameter, that is called :math:`c`. For a motivation for this mapping and the mathematical details see [LS2010]_. +.. _polynomial_kernel_approx: + +Polynomial Kernel Approximation via Tensor Sketch +------------------------------------------------- + +The :ref:`polynomial kernel <polynomial_kernel>` is a popular type of kernel +function given by: + +.. math:: + + k(x, y) = (\gamma x^\top y +c_0)^d + +where: + + * ``x``, ``y`` are the input vectors + * ``d`` is the kernel degree + +Intuitively, the feature space of the polynomial kernel of degree `d` +consists of all possible degree-`d` products among input features, which enables +learning algorithms using this kernel to account for interactions between features. + +The TensorSketch [PP2013]_ method, as implemented in :class:`PolynomialCountSketch`, is a +scalable, input data independent method for polynomial kernel approximation. +It is based on the concept of Count sketch [WIKICS]_ [CCF2002]_ , a dimensionality +reduction technique similar to feature hashing, which instead uses several +independent hash functions. TensorSketch obtains a Count Sketch of the outer product +of two vectors (or a vector with itself), which can be used as an approximation of the +polynomial kernel feature space. In particular, instead of explicitly computing +the outer product, TensorSketch computes the Count Sketch of the vectors and then +uses polynomial multiplication via the Fast Fourier Transform to compute the +Count Sketch of their outer product. + +Conveniently, the training phase of TensorSketch simply consists of initializing +some random variables. It is thus independent of the input data, i.e. it only +depends on the number of input features, but not the data values. +In addition, this method can transform samples in +:math:`\mathcal{O}(n_{\text{samples}}(n_{\text{features}} + n_{\text{components}} \log(n_{\text{components}})))` +time, where :math:`n_{\text{components}}` is the desired output dimension, +determined by ``n_components``. + +.. topic:: Examples: + + * :ref:`sphx_glr_auto_examples_plot_scalable_poly_kernels.py` + +.. _tensor_sketch_kernel_approx: Mathematical Details -------------------- @@ -201,3 +246,11 @@ or store training examples. .. [VVZ2010] `"Generalized RBF feature maps for Efficient Detection" <https://www.robots.ox.ac.uk/~vgg/publications/2010/Sreekanth10/sreekanth10.pdf>`_ Vempati, S. and Vedaldi, A. and Zisserman, A. and Jawahar, CV - 2010 + .. [PP2013] `"Fast and scalable polynomial kernels via explicit feature maps" + <https://doi.org/10.1145/2487575.2487591>`_ + Pham, N., & Pagh, R. - 2013 + .. [CCF2002] `"Finding frequent items in data streams" + <http://www.cs.princeton.edu/courses/archive/spring04/cos598B/bib/CharikarCF.pdf>`_ + Charikar, M., Chen, K., & Farach-Colton - 2002 + .. [WIKICS] `"Wikipedia: Count sketch" + <https://en.wikipedia.org/wiki/Count_sketch>`_ diff --git a/doc/whats_new/v0.24.rst b/doc/whats_new/v0.24.rst index 2682902a20983..c73f1a373a86b 100644 --- a/doc/whats_new/v0.24.rst +++ b/doc/whats_new/v0.24.rst @@ -221,6 +221,15 @@ Changelog - |Enhancement| :class:`isotonic.IsotonicRegression` now accepts 2darray with 1 feature as input array. :pr:`17379` by :user:`Jiaxiang <fujiaxiang>`. +:mod:`sklearn.kernel_approximation` +................................... + +- |Feature| Added class :class:`kernel_approximation.PolynomialCountSketch` + which implements the Tensor Sketch algorithm for polynomial kernel feature + map approximation. + :pr:`13003` by :user:`Daniel López Sánchez <lopeLH>`. + + :mod:`sklearn.linear_model` ........................... @@ -235,6 +244,7 @@ Changelog efficient leave-one-out cross-validation scheme ``cv=None``. :pr:`6624` by :user:`Marijn van Vliet <wmvanvliet>`. + :mod:`sklearn.manifold` ....................... diff --git a/examples/plot_scalable_poly_kernels.py b/examples/plot_scalable_poly_kernels.py new file mode 100644 index 0000000000000..845ba1fdf3050 --- /dev/null +++ b/examples/plot_scalable_poly_kernels.py @@ -0,0 +1,186 @@ +""" +======================================================= +Scalable learning with polynomial kernel aproximation +======================================================= + +This example illustrates the use of :class:`PolynomialCountSketch` to +efficiently generate polynomial kernel feature-space approximations. +This is used to train linear classifiers that approximate the accuracy +of kernelized ones. + +.. currentmodule:: sklearn.kernel_approximation + +We use the Covtype dataset [2], trying to reproduce the experiments on the +original paper of Tensor Sketch [1], i.e. the algorithm implemented by +:class:`PolynomialCountSketch`. + +First, we compute the accuracy of a linear classifier on the original +features. Then, we train linear classifiers on different numbers of +features (`n_components`) generated by :class:`PolynomialCountSketch`, +approximating the accuracy of a kernelized classifier in a scalable manner. +""" +print(__doc__) + +# Author: Daniel Lopez-Sanchez <lope@usal.es> +# License: BSD 3 clause +import matplotlib.pyplot as plt +from sklearn.datasets import fetch_covtype +from sklearn.model_selection import train_test_split +from sklearn.preprocessing import MinMaxScaler, Normalizer +from sklearn.svm import LinearSVC +from sklearn.kernel_approximation import PolynomialCountSketch +from sklearn.pipeline import Pipeline, make_pipeline +import time + +# %% +# Load the Covtype dataset, which contains 581,012 samples +# with 54 features each, distributed among 6 classes. The goal of this dataset +# is to predict forest cover type from cartographic variables only +# (no remotely sensed data). After loading, we transform it into a binary +# classification problem to match the version of the dataset in the +# LIBSVM webpage [2], which was the one used in [1]. + +X, y = fetch_covtype(return_X_y=True) + +y[y != 2] = 0 +y[y == 2] = 1 # We will try to separate class 2 from the other 6 classes. + +# %% +# Here we select 5,000 samples for training and 10,000 for testing. +# To actually reproduce the results in the original Tensor Sketch paper, +# select 100,000 for training. + +X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=5_000, + test_size=10_000, + random_state=42) + +# %% +# Now scale features to the range [0, 1] to match the format of the dataset in +# the LIBSVM webpage, and then normalize to unit length as done in the +# original Tensor Sketch paper [1]. + +mm = make_pipeline(MinMaxScaler(), Normalizer()) +X_train = mm.fit_transform(X_train) +X_test = mm.transform(X_test) + + +# %% +# As a baseline, train a linear SVM on the original features and print the +# accuracy. We also measure and store accuracies and training times to +# plot them latter. + +results = {} + +lsvm = LinearSVC() +start = time.time() +lsvm.fit(X_train, y_train) +lsvm_time = time.time() - start +lsvm_score = 100 * lsvm.score(X_test, y_test) + +results["LSVM"] = {"time": lsvm_time, "score": lsvm_score} +print(f"Linear SVM score on raw features: {lsvm_score:.2f}%") + +# %% +# Then we train linear SVMs on the features generated by +# :class:`PolynomialCountSketch` with different values for `n_components`, +# showing that these kernel feature approximations improve the accuracy +# of linear classification. In typical application scenarios, `n_components` +# should be larger than the number of features in the input representation +# in order to achieve an improvement with respect to linear classification. +# As a rule of thumb, the optimum of evaluation score / run time cost is +# typically achieved at around `n_components` = 10 * `n_features`, though this +# might depend on the specific dataset being handled. Note that, since the +# original samples have 54 features, the explicit feature map of the +# polynomial kernel of degree four would have approximately 8.5 million +# features (precisely, 54^4). Thanks to :class:`PolynomialCountSketch`, we can +# condense most of the discriminative information of that feature space into a +# much more compact representation. We repeat the experiment 5 times to +# compensate for the stochastic nature of :class:`PolynomialCountSketch`. + +n_runs = 3 +for n_components in [250, 500, 1000, 2000]: + + ps_lsvm_time = 0 + ps_lsvm_score = 0 + for _ in range(n_runs): + + pipeline = Pipeline(steps=[("kernel_approximator", + PolynomialCountSketch( + n_components=n_components, + degree=4)), + ("linear_classifier", LinearSVC())]) + + start = time.time() + pipeline.fit(X_train, y_train) + ps_lsvm_time += time.time() - start + ps_lsvm_score += 100 * pipeline.score(X_test, y_test) + + ps_lsvm_time /= n_runs + ps_lsvm_score /= n_runs + + results[f"LSVM + PS({n_components})"] = { + "time": ps_lsvm_time, "score": ps_lsvm_score + } + print(f"Linear SVM score on {n_components} PolynomialCountSketch " + + f"features: {ps_lsvm_score:.2f}%") + +# %% +# Train a kernelized SVM to see how well :class:`PolynomialCountSketch` +# is approximating the performance of the kernel. This, of course, may take +# some time, as the SVC class has a relatively poor scalability. This is the +# reason why kernel approximators are so useful: + +from sklearn.svm import SVC + +ksvm = SVC(C=500., kernel="poly", degree=4, coef0=0, gamma=1.) + +start = time.time() +ksvm.fit(X_train, y_train) +ksvm_time = time.time() - start +ksvm_score = 100 * ksvm.score(X_test, y_test) + +results["KSVM"] = {"time": ksvm_time, "score": ksvm_score} +print(f"Kernel-SVM score on raw featrues: {ksvm_score:.2f}%") + +# %% +# Finally, plot the resuts of the different methods against their training +# times. As we can see, the kernelized SVM achieves a higher accuracy, +# but its training time is much larger and, most importantly, will grow +# much faster if the number of training samples increases. + +N_COMPONENTS = [250, 500, 1000, 2000] + +fig, ax = plt.subplots(figsize=(7, 7)) +ax.scatter([results["LSVM"]["time"], ], [results["LSVM"]["score"], ], + label="Linear SVM", c="green", marker="^") + +ax.scatter([results["LSVM + PS(250)"]["time"], ], + [results["LSVM + PS(250)"]["score"], ], + label="Linear SVM + PolynomialCountSketch", c="blue") +for n_components in N_COMPONENTS: + ax.scatter([results[f"LSVM + PS({n_components})"]["time"], ], + [results[f"LSVM + PS({n_components})"]["score"], ], + c="blue") + ax.annotate(f"n_comp.={n_components}", + (results[f"LSVM + PS({n_components})"]["time"], + results[f"LSVM + PS({n_components})"]["score"]), + xytext=(-30, 10), textcoords="offset pixels") + +ax.scatter([results["KSVM"]["time"], ], [results["KSVM"]["score"], ], + label="Kernel SVM", c="red", marker="x") + +ax.set_xlabel("Training time (s)") +ax.set_ylabel("Accurary (%)") +ax.legend() +plt.show() + +# %% +# References +# ========== +# +# [1] Pham, Ninh and Rasmus Pagh. "Fast and scalable polynomial kernels via +# explicit feature maps." KDD '13 (2013). +# https://doi.org/10.1145/2487575.2487591 +# +# [2] LIBSVM binary datasets repository +# https://www.csie.ntu.edu.tw/~cjlin/libsvmtools/datasets/binary.html diff --git a/sklearn/kernel_approximation.py b/sklearn/kernel_approximation.py index 0310523e63213..19b2c432a758f 100644 --- a/sklearn/kernel_approximation.py +++ b/sklearn/kernel_approximation.py @@ -1,10 +1,11 @@ """ The :mod:`sklearn.kernel_approximation` module implements several -approximate kernel feature maps base on Fourier transforms. +approximate kernel feature maps based on Fourier transforms and Count Sketches. """ # Author: Andreas Mueller <amueller@ais.uni-bonn.de> -# +# Daniel Lopez-Sanchez (TensorSketch) <lope@usal.es> + # License: BSD 3 clause import warnings @@ -12,6 +13,10 @@ import numpy as np import scipy.sparse as sp from scipy.linalg import svd +try: + from scipy.fft import fft, ifft +except ImportError: # scipy < 1.4 + from scipy.fftpack import fft, ifft from .base import BaseEstimator from .base import TransformerMixin @@ -22,6 +27,171 @@ from .utils.validation import check_non_negative, _deprecate_positional_args +class PolynomialCountSketch(BaseEstimator, TransformerMixin): + """Polynomial kernel approximation via Tensor Sketch. + + Implements Tensor Sketch, which approximates the feature map + of the polynomial kernel:: + + K(X, Y) = (gamma * <X, Y> + coef0)^degree + + by efficiently computing a Count Sketch of the outer product of a + vector with itself using Fast Fourier Transforms (FFT). Read more in the + :ref:`User Guide <polynomial_kernel_approx>`. + + Parameters + ---------- + gamma : float, default=1.0 + Parameter of the polynomial kernel whose feature map + will be approximated. + + degree : int, default=2 + Degree of the polynomial kernel whose feature map + will be approximated. + + coef0 : int, default=0 + Constant term of the polynomial kernel whose feature map + will be approximated. + + n_components : int, default=100 + Dimensionality of the output feature space. Usually, n_components + should be greater than the number of features in input samples in + order to achieve good performance. The optimal score / run time + balance is typically achieved around n_components = 10 * n_features, + but this depends on the specific dataset being used. + + random_state : int, RandomState instance, default=None + Determines random number generation for indexHash and bitHash + initialization. Pass an int for reproducible results across multiple + function calls. See :term:`Glossary <random_state>`. + + Attributes + ---------- + indexHash_ : ndarray of shape (degree, n_features), dtype=int64 + Array of indexes in range [0, n_components) used to represent + the 2-wise independent hash functions for Count Sketch computation. + + bitHash_ : ndarray of shape (degree, n_features), dtype=float32 + Array with random entries in {+1, -1}, used to represent + the 2-wise independent hash functions for Count Sketch computation. + + Examples + -------- + >>> from sklearn.kernel_approximation import PolynomialCountSketch + >>> from sklearn.linear_model import SGDClassifier + >>> X = [[0, 0], [1, 1], [1, 0], [0, 1]] + >>> y = [0, 0, 1, 1] + >>> ps = PolynomialCountSketch(degree=3, random_state=1) + >>> X_features = ps.fit_transform(X) + >>> clf = SGDClassifier(max_iter=10, tol=1e-3) + >>> clf.fit(X_features, y) + SGDClassifier(max_iter=10) + >>> clf.score(X_features, y) + 1.0 + """ + + def __init__(self, *, gamma=1., degree=2, coef0=0, n_components=100, + random_state=None): + self.gamma = gamma + self.degree = degree + self.coef0 = coef0 + self.n_components = n_components + self.random_state = random_state + + def fit(self, X, y=None): + """Fit the model with X. + + Initializes the internal variables. The method needs no information + about the distribution of data, so we only care about n_features in X. + + Parameters + ---------- + X : {array-like, sparse matrix} of shape (n_samples, n_features) + Training data, where n_samples in the number of samples + and n_features is the number of features. + + Returns + ------- + self : object + Returns the transformer. + """ + if not self.degree >= 1: + raise ValueError(f"degree={self.degree} should be >=1.") + + X = self._validate_data(X, accept_sparse="csc") + random_state = check_random_state(self.random_state) + + n_features = X.shape[1] + if self.coef0 != 0: + n_features += 1 + + self.indexHash_ = random_state.randint(0, high=self.n_components, + size=(self.degree, n_features)) + + self.bitHash_ = random_state.choice(a=[-1, 1], + size=(self.degree, n_features)) + return self + + def transform(self, X): + """Generate the feature map approximation for X. + + Parameters + ---------- + X : {array-like}, shape (n_samples, n_features) + New data, where n_samples in the number of samples + and n_features is the number of features. + + Returns + ------- + X_new : array-like, shape (n_samples, n_components) + """ + + check_is_fitted(self) + X = self._validate_data(X, accept_sparse="csc") + + X_gamma = np.sqrt(self.gamma) * X + + if sp.issparse(X_gamma) and self.coef0 != 0: + X_gamma = sp.hstack([X_gamma, np.sqrt(self.coef0) * + np.ones((X_gamma.shape[0], 1))], + format="csc") + + elif not sp.issparse(X_gamma) and self.coef0 != 0: + X_gamma = np.hstack([X_gamma, np.sqrt(self.coef0) * + np.ones((X_gamma.shape[0], 1))]) + + if X_gamma.shape[1] != self.indexHash_.shape[1]: + raise ValueError("Number of features of test samples does not" + " match that of training samples.") + + count_sketches = np.zeros( + (X_gamma.shape[0], self.degree, self.n_components)) + + if sp.issparse(X_gamma): + for j in range(X_gamma.shape[1]): + for d in range(self.degree): + iHashIndex = self.indexHash_[d, j] + iHashBit = self.bitHash_[d, j] + count_sketches[:, d, iHashIndex] += \ + (iHashBit * X_gamma[:, j]).toarray().ravel() + + else: + for j in range(X_gamma.shape[1]): + for d in range(self.degree): + iHashIndex = self.indexHash_[d, j] + iHashBit = self.bitHash_[d, j] + count_sketches[:, d, iHashIndex] += \ + iHashBit * X_gamma[:, j] + + # For each same, compute a count sketch of phi(x) using the polynomial + # multiplication (via FFT) of p count sketches of x. + count_sketches_fft = fft(count_sketches, axis=2, overwrite_x=True) + count_sketches_fft_prod = np.prod(count_sketches_fft, axis=1) + data_sketch = np.real(ifft(count_sketches_fft_prod, overwrite_x=True)) + + return data_sketch + + class RBFSampler(TransformerMixin, BaseEstimator): """Approximates feature map of an RBF kernel by Monte Carlo approximation of its Fourier transform.

diff --git a/sklearn/tests/test_kernel_approximation.py b/sklearn/tests/test_kernel_approximation.py index 8d37ce218f227..0cee04f9f2d0a 100644 --- a/sklearn/tests/test_kernel_approximation.py +++ b/sklearn/tests/test_kernel_approximation.py @@ -10,6 +10,7 @@ from sklearn.kernel_approximation import AdditiveChi2Sampler from sklearn.kernel_approximation import SkewedChi2Sampler from sklearn.kernel_approximation import Nystroem +from sklearn.kernel_approximation import PolynomialCountSketch from sklearn.metrics.pairwise import polynomial_kernel, rbf_kernel, chi2_kernel # generate data @@ -20,6 +21,40 @@ Y /= Y.sum(axis=1)[:, np.newaxis] +@pytest.mark.parametrize('degree', [-1, 0]) +def test_polynomial_count_sketch_raises_if_degree_lower_than_one(degree): + with pytest.raises(ValueError, match=f'degree={degree} should be >=1.'): + ps_transform = PolynomialCountSketch(degree=degree) + ps_transform.fit(X, Y) + + +@pytest.mark.parametrize('X', [X, csr_matrix(X)]) +@pytest.mark.parametrize('Y', [Y, csr_matrix(Y)]) +@pytest.mark.parametrize('gamma', [0.1, 1, 2.5]) +@pytest.mark.parametrize('degree', [1, 2, 3]) +@pytest.mark.parametrize('coef0', [0, 1, 2.5]) +def test_polynomial_count_sketch(X, Y, gamma, degree, coef0): + # test that PolynomialCountSketch approximates polynomial + # kernel on random data + + # compute exact kernel + kernel = polynomial_kernel(X, Y, gamma=gamma, degree=degree, coef0=coef0) + + # approximate kernel mapping + ps_transform = PolynomialCountSketch(n_components=5000, gamma=gamma, + coef0=coef0, degree=degree, + random_state=42) + X_trans = ps_transform.fit_transform(X) + Y_trans = ps_transform.transform(Y) + kernel_approx = np.dot(X_trans, Y_trans.T) + + error = kernel - kernel_approx + assert np.abs(np.mean(error)) <= 0.05 # close to unbiased + np.abs(error, out=error) + assert np.max(error) <= 0.1 # nothing too far off + assert np.mean(error) <= 0.05 # mean is fairly close + + def _linear_kernel(X, Y): return np.dot(X, Y.T)

diff --git a/doc/modules/classes.rst b/doc/modules/classes.rst index 2e54d000a13aa..70a5174629f37 100644 --- a/doc/modules/classes.rst +++ b/doc/modules/classes.rst @@ -706,6 +706,7 @@ Plotting kernel_approximation.AdditiveChi2Sampler kernel_approximation.Nystroem + kernel_approximation.PolynomialCountSketch kernel_approximation.RBFSampler kernel_approximation.SkewedChi2Sampler diff --git a/doc/modules/kernel_approximation.rst b/doc/modules/kernel_approximation.rst index fb3843c6bc045..4f5ee46a42057 100644 --- a/doc/modules/kernel_approximation.rst +++ b/doc/modules/kernel_approximation.rst @@ -149,6 +149,51 @@ above for the :class:`RBFSampler`. The only difference is in the free parameter, that is called :math:`c`. For a motivation for this mapping and the mathematical details see [LS2010]_. +.. _polynomial_kernel_approx: + +Polynomial Kernel Approximation via Tensor Sketch +------------------------------------------------- + +The :ref:`polynomial kernel <polynomial_kernel>` is a popular type of kernel +function given by: + +.. math:: + + k(x, y) = (\gamma x^\top y +c_0)^d + +where: + + * ``x``, ``y`` are the input vectors + * ``d`` is the kernel degree + +Intuitively, the feature space of the polynomial kernel of degree `d` +consists of all possible degree-`d` products among input features, which enables +learning algorithms using this kernel to account for interactions between features. + +The TensorSketch [PP2013]_ method, as implemented in :class:`PolynomialCountSketch`, is a +scalable, input data independent method for polynomial kernel approximation. +It is based on the concept of Count sketch [WIKICS]_ [CCF2002]_ , a dimensionality +reduction technique similar to feature hashing, which instead uses several +independent hash functions. TensorSketch obtains a Count Sketch of the outer product +of two vectors (or a vector with itself), which can be used as an approximation of the +polynomial kernel feature space. In particular, instead of explicitly computing +the outer product, TensorSketch computes the Count Sketch of the vectors and then +uses polynomial multiplication via the Fast Fourier Transform to compute the +Count Sketch of their outer product. + +Conveniently, the training phase of TensorSketch simply consists of initializing +some random variables. It is thus independent of the input data, i.e. it only +depends on the number of input features, but not the data values. +In addition, this method can transform samples in +:math:`\mathcal{O}(n_{\text{samples}}(n_{\text{features}} + n_{\text{components}} \log(n_{\text{components}})))` +time, where :math:`n_{\text{components}}` is the desired output dimension, +determined by ``n_components``. + +.. topic:: Examples: + + * :ref:`sphx_glr_auto_examples_plot_scalable_poly_kernels.py` + +.. _tensor_sketch_kernel_approx: Mathematical Details -------------------- @@ -201,3 +246,11 @@ or store training examples. .. [VVZ2010] `"Generalized RBF feature maps for Efficient Detection" <https://www.robots.ox.ac.uk/~vgg/publications/2010/Sreekanth10/sreekanth10.pdf>`_ Vempati, S. and Vedaldi, A. and Zisserman, A. and Jawahar, CV - 2010 + .. [PP2013] `"Fast and scalable polynomial kernels via explicit feature maps" + <https://doi.org/10.1145/2487575.2487591>`_ + Pham, N., & Pagh, R. - 2013 + .. [CCF2002] `"Finding frequent items in data streams" + <http://www.cs.princeton.edu/courses/archive/spring04/cos598B/bib/CharikarCF.pdf>`_ + Charikar, M., Chen, K., & Farach-Colton - 2002 + .. [WIKICS] `"Wikipedia: Count sketch" + <https://en.wikipedia.org/wiki/Count_sketch>`_ diff --git a/doc/whats_new/v0.24.rst b/doc/whats_new/v0.24.rst index 2682902a20983..c73f1a373a86b 100644 --- a/doc/whats_new/v0.24.rst +++ b/doc/whats_new/v0.24.rst @@ -221,6 +221,15 @@ Changelog - |Enhancement| :class:`isotonic.IsotonicRegression` now accepts 2darray with 1 feature as input array. :pr:`17379` by :user:`Jiaxiang <fujiaxiang>`. +:mod:`sklearn.kernel_approximation` +................................... + +- |Feature| Added class :class:`kernel_approximation.PolynomialCountSketch` + which implements the Tensor Sketch algorithm for polynomial kernel feature + map approximation. + :pr:`13003` by :user:`Daniel López Sánchez <lopeLH>`. + + :mod:`sklearn.linear_model` ........................... @@ -235,6 +244,7 @@ Changelog efficient leave-one-out cross-validation scheme ``cv=None``. :pr:`6624` by :user:`Marijn van Vliet <wmvanvliet>`. + :mod:`sklearn.manifold` .......................

[ { "components": [ { "doc": "Polynomial kernel approximation via Tensor Sketch.\n\nImplements Tensor Sketch, which approximates the feature map\nof the polynomial kernel::\n\n K(X, Y) = (gamma * <X, Y> + coef0)^degree\n\nby efficiently computing a Count Sketch of the outer product of a\nvector w...

[ "sklearn/tests/test_kernel_approximation.py::test_polynomial_count_sketch_raises_if_degree_lower_than_one[-1]", "sklearn/tests/test_kernel_approximation.py::test_polynomial_count_sketch_raises_if_degree_lower_than_one[0]", "sklearn/tests/test_kernel_approximation.py::test_polynomial_count_sketch[0-1-0.1-Y0-X0]"...

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG+3] FEA Add PolynomialCountSketch to Kernel Approximation module This PR adds the **Tensor Sketch** [1] algorithm for polynomial kernel feature map approximation to the Kernel Approximation module. Tensor Sketch is a well established method for kernel feature map approximation, which has been broadly applied in the literature. For instance, it has recently gained a lot of popularity to accelerate certain bilinear models [2]. While the current kernel approximation module contains various kernel approximation methods, polynomial kernels are missing, so including TensorSketch completes the functionality of this module by providing an efficient and data-independent polynomial kernel approximation technique. The PR contains the implementation of the algorithm, the corresponding tests, an example script, and a description of the algorithm in the documentation page of the kernel approximation module. This implementation has been tested to produce the same results as the original matlab implementation provided by the author of the algorithm [1]. [1] [Pham, N., & Pagh, R. (2013, August). Fast and scalable polynomial kernels via explicit feature maps. In Proceedings of the 19th ACM SIGKDD international conference on Knowledge discovery and data mining (pp. 239-247). ACM.](https://scholar.google.es/scholar?hl=es&as_sdt=0%2C5&q=Fast+and+scalable+polynomial+kernels+via+explicit+feature+maps&btnG=) [2] [Gao, Y., Beijbom, O., Zhang, N., & Darrell, T. (2016). Compact bilinear pooling. In Proceedings of the IEEE conference on computer vision and pattern recognition (pp. 317-326).](https://scholar.google.es/scholar?hl=es&as_sdt=0%2C5&q=Compact+bilinear+pooling%2C+Y.+Gao&btnG=) _____ Work for follow-up PR: - [ ] @rth: This can be a follow up issue/PR, and would need double checking but since the count_sketches input is real you can likely use rfft and irfft witch would be faster. - [ ] @rth: The issue is that calling fit twice would produce a different seed and therefore a different result, since RandomState instance is mutable. In #14605 for a similar use case, we added a seed variable in transform, but I'm not particularly happy with that outcome either. This is probably fine as is, we would just have to address this globally at some point in #14042 - [ ] @rth: It could be worth considering whether it would make sense thesholding (in the above example 1e-15 would be ok as a threshold) and converting back to sparse. Though the intermediary step with the FFT would still be dense with the associated memory requirements, maybe it could be worth chunking with respect to n_samples not sure (https://github.com/scikit-learn/scikit-learn/pull/13003#issuecomment-673424927). ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/kernel_approximation.py] (definition of PolynomialCountSketch:) class PolynomialCountSketch(BaseEstimator, TransformerMixin): """Polynomial kernel approximation via Tensor Sketch. Implements Tensor Sketch, which approximates the feature map of the polynomial kernel:: K(X, Y) = (gamma * <X, Y> + coef0)^degree by efficiently computing a Count Sketch of the outer product of a vector with itself using Fast Fourier Transforms (FFT). Read more in the :ref:`User Guide <polynomial_kernel_approx>`. Parameters ---------- gamma : float, default=1.0 Parameter of the polynomial kernel whose feature map will be approximated. degree : int, default=2 Degree of the polynomial kernel whose feature map will be approximated. coef0 : int, default=0 Constant term of the polynomial kernel whose feature map will be approximated. n_components : int, default=100 Dimensionality of the output feature space. Usually, n_components should be greater than the number of features in input samples in order to achieve good performance. The optimal score / run time balance is typically achieved around n_components = 10 * n_features, but this depends on the specific dataset being used. random_state : int, RandomState instance, default=None Determines random number generation for indexHash and bitHash initialization. Pass an int for reproducible results across multiple function calls. See :term:`Glossary <random_state>`. Attributes ---------- indexHash_ : ndarray of shape (degree, n_features), dtype=int64 Array of indexes in range [0, n_components) used to represent the 2-wise independent hash functions for Count Sketch computation. bitHash_ : ndarray of shape (degree, n_features), dtype=float32 Array with random entries in {+1, -1}, used to represent the 2-wise independent hash functions for Count Sketch computation. Examples -------- >>> from sklearn.kernel_approximation import PolynomialCountSketch >>> from sklearn.linear_model import SGDClassifier >>> X = [[0, 0], [1, 1], [1, 0], [0, 1]] >>> y = [0, 0, 1, 1] >>> ps = PolynomialCountSketch(degree=3, random_state=1) >>> X_features = ps.fit_transform(X) >>> clf = SGDClassifier(max_iter=10, tol=1e-3) >>> clf.fit(X_features, y) SGDClassifier(max_iter=10) >>> clf.score(X_features, y) 1.0""" (definition of PolynomialCountSketch.__init__:) def __init__(self, *, gamma=1., degree=2, coef0=0, n_components=100, random_state=None): (definition of PolynomialCountSketch.fit:) def fit(self, X, y=None): """Fit the model with X. Initializes the internal variables. The method needs no information about the distribution of data, so we only care about n_features in X. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data, where n_samples in the number of samples and n_features is the number of features. Returns ------- self : object Returns the transformer.""" (definition of PolynomialCountSketch.transform:) def transform(self, X): """Generate the feature map approximation for X. Parameters ---------- X : {array-like}, shape (n_samples, n_features) New data, where n_samples in the number of samples and n_features is the number of features. Returns ------- X_new : array-like, shape (n_samples, n_components)""" [end of new definitions in sklearn/kernel_approximation.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

54ce4222694819ad52d544ce5cba5da274c34ab7

rytilahti__python-miio-451

451

rytilahti/python-miio

null

05f55bc6b6bea9cb0bc8a721e24631e0bac2ec39

2019-01-07T20:06:28Z

diff --git a/miio/airhumidifier.py b/miio/airhumidifier.py index 031d30c04..a143d1171 100644 --- a/miio/airhumidifier.py +++ b/miio/airhumidifier.py @@ -337,6 +337,20 @@ def set_led_brightness(self, brightness: LedBrightness): """Set led brightness.""" return self.send("set_led_b", [brightness.value]) + @command( + click.argument("led", type=bool), + default_output=format_output( + lambda led: "Turning on LED" + if led else "Turning off LED" + ) + ) + def set_led(self, led: bool): + """Turn led on/off.""" + if led: + return self.set_led_brightness(LedBrightness.Bright) + else: + return self.set_led_brightness(LedBrightness.Off) + @command( click.argument("buzzer", type=bool), default_output=format_output(

diff --git a/miio/tests/test_airhumidifier.py b/miio/tests/test_airhumidifier.py index a9bcfb973..af933d05f 100644 --- a/miio/tests/test_airhumidifier.py +++ b/miio/tests/test_airhumidifier.py @@ -147,6 +147,16 @@ def led_brightness(): self.device.set_led_brightness(LedBrightness.Off) assert led_brightness() == LedBrightness.Off + def test_set_led(self): + def led_brightness(): + return self.device.status().led_brightness + + self.device.set_led(True) + assert led_brightness() == LedBrightness.Bright + + self.device.set_led(False) + assert led_brightness() == LedBrightness.Off + def test_set_buzzer(self): def buzzer(): return self.device.status().buzzer @@ -343,6 +353,16 @@ def led_brightness(): self.device.set_led_brightness(LedBrightness.Off) assert led_brightness() == LedBrightness.Off + def test_set_led(self): + def led_brightness(): + return self.device.status().led_brightness + + self.device.set_led(True) + assert led_brightness() == LedBrightness.Bright + + self.device.set_led(False) + assert led_brightness() == LedBrightness.Off + def test_set_buzzer(self): def buzzer(): return self.device.status().buzzer

[ { "components": [ { "doc": "Turn led on/off.", "lines": [ 347, 352 ], "name": "AirHumidifier.set_led", "signature": "def set_led(self, led: bool):", "type": "function" } ], "file": "miio/airhumidifier.py" } ]

[ "miio/tests/test_airhumidifier.py::TestAirHumidifierV1::test_set_led", "miio/tests/test_airhumidifier.py::TestAirHumidifierCA1::test_set_led" ]

[ "miio/tests/test_airhumidifier.py::TestAirHumidifierV1::test_off", "miio/tests/test_airhumidifier.py::TestAirHumidifierV1::test_on", "miio/tests/test_airhumidifier.py::TestAirHumidifierV1::test_set_buzzer", "miio/tests/test_airhumidifier.py::TestAirHumidifierV1::test_set_child_lock", "miio/tests/test_airhum...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Air Humidifier: Add set_led method ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in miio/airhumidifier.py] (definition of AirHumidifier.set_led:) def set_led(self, led: bool): """Turn led on/off.""" [end of new definitions in miio/airhumidifier.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

62427d2f796e603520acca3b57b29ec3e6489bca

conan-io__conan-4238

4,238

conan-io/conan

null

fe322a672307d29f99d2e7bc1c02c45c835028d7

2019-01-07T13:28:46Z

diff --git a/conans/util/sha.py b/conans/util/sha.py index 1e50aff2c80..026bfc98df8 100644 --- a/conans/util/sha.py +++ b/conans/util/sha.py @@ -7,3 +7,11 @@ def sha1(value): md = hashlib.sha1() md.update(value) return md.hexdigest() + + +def sha256(value): + if value is None: + return None + md = hashlib.sha256() + md.update(value) + return md.hexdigest() diff --git a/conans/util/windows.py b/conans/util/windows.py index b57dd1df2bc..3cb9e2497aa 100644 --- a/conans/util/windows.py +++ b/conans/util/windows.py @@ -4,8 +4,11 @@ from conans.util.env_reader import get_env from conans.util.files import load, mkdir, rmdir, save +from conans.util.log import logger +from conans.util.sha import sha256 CONAN_LINK = ".conan_link" +CONAN_REAL_PATH = "real_path.txt" def conan_expand_user(path): @@ -69,7 +72,15 @@ def path_shortener(path, short_paths): # cmd can fail if trying to set ACL in non NTFS drives, ignoring it. pass - redirect = tempfile.mkdtemp(dir=short_home, prefix="") + redirect = hashed_redirect(short_home, path) + if not redirect: + logger.warn("Failed to create a deterministic short path in %s", short_home) + redirect = tempfile.mkdtemp(dir=short_home, prefix="") + + # Save the full path of the local cache directory where the redirect is from. + # This file is for debugging purposes and not used by Conan. + save(os.path.join(redirect, CONAN_REAL_PATH), path) + # This "1" is the way to have a non-existing directory, so commands like # shutil.copytree() to it, works. It can be removed without compromising the # temp folder generator and conan-links consistency @@ -102,3 +113,17 @@ def rm_conandir(path): short_path = load(link) rmdir(os.path.dirname(short_path)) rmdir(path) + + +def hashed_redirect(base, path, min_length=6, attempts=10): + max_length = min_length + attempts + + full_hash = sha256(path.encode()) + assert len(full_hash) > max_length + + for length in range(min_length, max_length): + redirect = os.path.join(base, full_hash[:length]) + if not os.path.exists(redirect): + return redirect + else: + return None

diff --git a/conans/test/unittests/util/hashed_path_test.py b/conans/test/unittests/util/hashed_path_test.py new file mode 100644 index 00000000000..05b30f1bcfb --- /dev/null +++ b/conans/test/unittests/util/hashed_path_test.py @@ -0,0 +1,33 @@ +import os +import unittest + +from conans.test.utils.test_files import temp_folder + +from conans.util.windows import hashed_redirect + + +class HashedPathTest(unittest.TestCase): + def setUp(self): + self.path = "package_name/version/user/channel/export" + self.folder = temp_folder() + + def test_creates_deterministic_path(self): + first = hashed_redirect(self.folder, self.path) + second = hashed_redirect(self.folder, self.path) + self.assertEqual(first, second) + + def test_avoids_collisions(self): + first = hashed_redirect(self.folder, self.path) + os.mkdir(first) + + second = hashed_redirect(self.folder, self.path) + self.assertLess(len(first), len(second)) + + def test_give_up_if_cannot_avoid_collisions(self): + # Make two attempts to generate distinct path names + os.mkdir(hashed_redirect(self.folder, self.path)) + os.mkdir(hashed_redirect(self.folder, self.path)) + + # The two attempts were already spent, so the following should give up + redirect = hashed_redirect(self.folder, self.path, attempts=2) + self.assertEqual(None, redirect)

[ { "components": [ { "doc": "", "lines": [ 12, 17 ], "name": "sha256", "signature": "def sha256(value):", "type": "function" } ], "file": "conans/util/sha.py" }, { "components": [ { "doc": "", "l...

[ "conans/test/unittests/util/hashed_path_test.py::HashedPathTest::test_avoids_collisions", "conans/test/unittests/util/hashed_path_test.py::HashedPathTest::test_creates_deterministic_path", "conans/test/unittests/util/hashed_path_test.py::HashedPathTest::test_give_up_if_cannot_avoid_collisions" ]

[]

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> Feature/deterministic short paths Changelog: Feature: Generate deterministic short paths on Windows Docs: Omit Close #3971 This PR implements the generation of the deterministic paths on Windows. The feature was proposed and discussed in #3971. - [X] Refer to the issue that supports this Pull Request. - [X] If the issue has missing info, explain the purpose/use case/pain/need that covers this Pull Request. - [X] I've read the [Contributing guide](https://github.com/conan-io/conan/blob/develop/.github/CONTRIBUTING.md). - [X] I've followed the PEP8 style guides for Python code. - [ ] I've opened another PR in the Conan docs repo to the ``develop`` branch, documenting this one. <sup>**Note:** By default this PR will skip the slower tests and will use a limited set of python versions. Check [here](https://github.com/conan-io/conan/blob/develop/.github/PR_INCREASE_TESTING.md) how to increase the testing level by writing some tags in the current PR body text.</sup> ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in conans/util/sha.py] (definition of sha256:) def sha256(value): [end of new definitions in conans/util/sha.py] [start of new definitions in conans/util/windows.py] (definition of hashed_redirect:) def hashed_redirect(base, path, min_length=6, attempts=10): [end of new definitions in conans/util/windows.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> deterministic short_paths (the issue template is shamelessly stolen from https://github.com/concourse/concourse) ## What challenge are you facing? We're building a big C++ application in our CI system that uses many Conan packages. Build times can be as long as 1 hour so we use compilation caches (ccache/clcache) to speed up the build. This use case is also mentioned in #3502. Some of our Conan packages depend on the `short_paths` option, without this they don't build on Windows, at all. The problem is that the generated short paths aren't deterministic and this makes it impossible to re-use the compilation cache database on a different worker. Only worker-local cache is viable. Our workers are short lived, their virtual machines are destroyed and recreated daily. Using a worker-local compilation cache is sub-optimal because its lifetime is one day, hence the system needs multiple builds daily to warm up. ## What would make this better? A deterministic short path would allow the use of a global compilation cache greatly speeding up our builds. The following proposal builds upon the idea dicussed in #3502. Currently the `conans.util.windows.path_shortener` generates a redirect pointing to (using the default values): ``` C:\.conan\<random_name>\1 ``` Imagine, instead of this, having something like ``` C:\.conan\<deterministic_short_path>\1 ``` where the ``` deterministic_short_path = hash(name, version, user, channel, package_id) ``` In other words, all the path components appearing in the Conan data directory (available from `conan_reference` and `package_reference` in `conans.paths.py`) will be hashed to a single, deterministic value. To keep the path short we would truncate the output of a typical hash function such as MD5 or SHA. So the short path would look like: ``` C:\.conan\f5b96df\1 ``` This would also solve issues like #1881 ## Are you interested in implementing this yourself? If you think this proposal is feasible we would be very happy to implement this feature. ---------- The only problem with this approach, is the possibility of a collision. Known as the "birthday problem", the probability for 7 digits is here: https://github.com/source-foundry/font-v/issues/2#issuecomment-327189455 That will be not very likely, but still very possible. Might need to go for 8 digits. That is also 2 more than current random length, which also might eventually break some package that was really in the limit. I think it could make sense to take the risk, but need to discuss it. Thanks for the offer to implement it yourself! Will contact shortly if approved. @memsharded thanks for your quick response. The collisions are possible, however generated hashes don't have to be unique globally. The collisions need to be sufficiently rare on a particular host. Picking the right length is important, though. Using the simple [square approximation from this answer](https://stackoverflow.com/a/42567312) p ~= (n^2)/(2m) Where n is the number of items and m is the number of possibilities for each item. The number of possibilities for a hex string is 16^c where c is the number of characters. * n = 100, c=4 p ~= 0.08 * n = 1000, c = 6 gives p ~= 0.03 * n = 5000, c=7 gives p ~= 0.05 * n = 10000, c=8 gives p ~=0.01 I guess the question is how many packages a typical host has in its database (assuming that the short_path feature is always on). (co-author of proposal here) ... and, since these hashes would have meaning only locally, we could even consider a user-customizable parameter for the hash length if really needed. This would not solve the problem of the path being too long in certain unlucky cases, but it would solve the problem of the collisions if the local host has a huge number of packages. Yes, that means, that with a local cache of up to 1000 packages, if using 8 bits, the probability of collision would be around 0.0001 (0.01%) Discussing with @marco-m we could make the redirect collision-free if we implemented this as follows: * compute the hash * try to create the redirect using the first N characters * if this path already exists under `c:\.conan\` use an extra digit and try to create the redirect using the first N+1 characters Not sure it is enough @wagdav There is no guarantee that they will be evaluated in the same order Creating of short paths: - Pkg/1@user/channel => hash f12345 - Pkg2/1@user/channel => (collides) => hash f123456 If for some reason, not unlikely, a different run later that tries to use the same cache runs ``Pkg2/1@user/channel`` first, then won't it map to ``f12345``? Is there something I am missing? I think that the approach could work, @memsharded. In your scenario, if `Pkg2/1@user/channel` is created first, then it could be already in the cache (will use the previously used path stored in the CONAN_LINK file) or created again and look for a new tmp directory not existing in the cache. Something like this in the `path_shortener` function should work: ```python full_hash = hash_function(path) # Use path as input, all the settings/options/ids should already be there min_length = 4 # Any number will work max_length = 8 assert len(full_hash) > max_length # Should be easy enough for a hash function redirect = os.path.join(short_home, full_hash[:min_length]) while os.path.exists(redirect) and min_length != max_length: min_length += 1 redirect = os.path.join(short_home, full_hash[:min_length]) # If everything exists, then fallback to previous behaviour if min_length == max_length: redirect = tempfile.mkdtemp(dir=short_home, prefix="") ``` Main issue here: if you remove a package from the Conan cache, will the linked folder be removed too? If not, all the proposed `redirect` will eventually fail for packages that has been created and removed several times. After sharing this issue with the team, we are willing to accept this PR. The implementation should follow the idea above: - hash_function: any `sha` should be enough - let's get a deterministic path from `6` to `15` chars (fallback to `mkdtemp`). Although short paths should be erased when the path in the conan cache is deleted, we keep the _temp-dir_ fallback just in case there is a bug for any package and the short paths are not deleted. - add a _real_path.txt_ file inside the shortened path directory with the full path to the Conan cache it is linked from. This way we will be able to track the issue mentioned above. Thanks very much for offering your help @wagdav ! @memsharded, @lasote, @jgsogo we (@wagdav and myself, and surely also @piponazo) wanted to tell you that we admire how the Conan project treats contributors and users. You are doing a fantastic work. > hash_function: any sha should be enough this might be the case, but I would strongly advise against using sha-1. Even this might not be a security relevant thing in this use case (debatable), insecure hashing algorithm should just go away altogether. I would say it is counterproductive from a "big picture" point of view to introduce broken hashing algorithm in new code no matter the usage. (Also I'm pretty sure that I have heard that several e.g. government institutions are forbidden from using any software which contains broken hashing algorithm no matter the usage. But that was a while ago please don't pin me down on this.) I don't see any security concern here at all, so sha1 should be perfectly fine. We are taking a known, public path, and mapping it to another path. If someone has access to the system, then the smallest problem is this hash. Furthermore, we are just going to keep a very few 6-7-8 characters of it... Furthermore other hashing algorithms are already being used in Conan (md5 for file checksums, sha1 for https deduplication checks). There are plans to upgrade them, but at the moment I see no concern for using a sha1 at this moment. Even git is sha1 based :) :) :) Hi @wagdav , @marco-m did you have the chance to work on this? Would you need some help or guidance? I am tentatively assigning @wagdav this issue, but tell otherwise and we will plan for it. Thanks! > I don't see any security concern here at all Yes, but what I tried to say it no matter in what environment you are using it I don't think it is good to have a dependency on a broken hash algorithm. > There are plans to upgrade them, but at the moment I see no concern for using a sha1 at this moment. Even git is sha1 based :) :) :) Even more when you have plans to upgrade, why introducing SHA-1 now once more? And [git is actively working](https://github.com/git/git/blob/752414ae4310cd304f5e31649aaab2dcf307057c/Documentation/technical/hash-function-transition.txt) to get rid of of SHA-1 since [SHAttered](https://shattered.io) and settled for [SHA-256](https://github.com/git/git/commit/0ed8d8da374f648764758f13038ca93af87ab800). Maybe asking this in the other direction: is there a downside of using e.g. SHA-256? (even though, yes it gets cut of anyway and doesn't seem to be security relevant in this specific use case). Fair point, yes, lets do sha2 then. I was not arguing against it, I was arguing against the fact that using other algorithm here would imply some kind of vulnerability or insecurity in conan. Thanks! @memsharded Thanks for the follow-up! We didn't forget about this issue! We are planning to work on this next week! I'll let you know if we're blocked! @memsharded FYI we have to postpone to beginning of next year. Hi, we want to release this for Conan 1.12 at the end of the month. Would you be able to do it? We will do it otherwise Yes! We'll be submitting a PR next week! :crossed_fingers: -------------------- </issues>

4a5b19a75db9225316c8cb022a2dfb9705a2af34

scikit-learn__scikit-learn-12908

12,908

scikit-learn/scikit-learn

0.21

314686a65d543bd3b36d2af4b34ed23711991a57

2019-01-03T04:21:02Z

diff --git a/doc/modules/preprocessing.rst b/doc/modules/preprocessing.rst index 77abe294a331b..7b7c447beb34d 100644 --- a/doc/modules/preprocessing.rst +++ b/doc/modules/preprocessing.rst @@ -489,7 +489,7 @@ Continuing the example above:: >>> enc = preprocessing.OneHotEncoder() >>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']] >>> enc.fit(X) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - OneHotEncoder(categorical_features=None, categories=None, + OneHotEncoder(categorical_features=None, categories=None, drop=None, dtype=<... 'numpy.float64'>, handle_unknown='error', n_values=None, sparse=True) >>> enc.transform([['female', 'from US', 'uses Safari'], @@ -516,7 +516,7 @@ dataset:: >>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']] >>> enc.fit(X) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE OneHotEncoder(categorical_features=None, - categories=[...], + categories=[...], drop=None, dtype=<... 'numpy.float64'>, handle_unknown='error', n_values=None, sparse=True) >>> enc.transform([['female', 'from Asia', 'uses Chrome']]).toarray() @@ -533,13 +533,31 @@ columns for this feature will be all zeros >>> enc = preprocessing.OneHotEncoder(handle_unknown='ignore') >>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']] >>> enc.fit(X) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - OneHotEncoder(categorical_features=None, categories=None, + OneHotEncoder(categorical_features=None, categories=None, drop=None, dtype=<... 'numpy.float64'>, handle_unknown='ignore', n_values=None, sparse=True) >>> enc.transform([['female', 'from Asia', 'uses Chrome']]).toarray() array([[1., 0., 0., 0., 0., 0.]]) +It is also possible to encode each column into ``n_categories - 1`` columns +instead of ``n_categories`` columns by using the ``drop`` parameter. This +parameter allows the user to specify a category for each feature to be dropped. +This is useful to avoid co-linearity in the input matrix in some classifiers. +Such functionality is useful, for example, when using non-regularized +regression (:class:`LinearRegression <sklearn.linear_model.LinearRegression>`), +since co-linearity would cause the covariance matrix to be non-invertible. +When this paramenter is not None, ``handle_unknown`` must be set to +``error``:: + + >>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']] + >>> drop_enc = preprocessing.OneHotEncoder(drop='first').fit(X) + >>> drop_enc.categories_ + [array(['female', 'male'], dtype=object), array(['from Europe', 'from US'], dtype=object), array(['uses Firefox', 'uses Safari'], dtype=object)] + >>> drop_enc.transform(X).toarray() + array([[1., 1., 1.], + [0., 0., 0.]]) + See :ref:`dict_feature_extraction` for categorical features that are represented as a dict, not as scalars. diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 36582d834c708..f828c17a0c5fe 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -278,6 +278,11 @@ Support for Python 3.4 and below has been officially dropped. :class:`preprocessing.StandardScaler`. :issue:`13007` by :user:`Raffaello Baluyot <baluyotraf>` +- |Feature| :class:`OneHotEncoder` now supports dropping one feature per category + with a new drop parameter. :issue:`12908` by + :user:`Drew Johnston <drewmjohnston>`. + + :mod:`sklearn.tree` ................... - |Feature| Decision Trees can now be plotted with matplotlib using diff --git a/sklearn/preprocessing/_encoders.py b/sklearn/preprocessing/_encoders.py index be3e8a9967cfe..3560c3bfcfac0 100644 --- a/sklearn/preprocessing/_encoders.py +++ b/sklearn/preprocessing/_encoders.py @@ -2,7 +2,6 @@ # Joris Van den Bossche <jorisvandenbossche@gmail.com> # License: BSD 3 clause - import numbers import warnings @@ -158,6 +157,18 @@ class OneHotEncoder(_BaseEncoder): The used categories can be found in the ``categories_`` attribute. + drop : 'first' or a list/array of shape (n_features,), default=None. + Specifies a methodology to use to drop one of the categories per + feature. This is useful in situations where perfectly collinear + features cause problems, such as when feeding the resulting data + into a neural network or an unregularized regression. + + - None : retain all features (the default). + - 'first' : drop the first category in each feature. If only one + category is present, the feature will be dropped entirely. + - array : ``drop[i]`` is the category in feature ``X[:, i]`` that + should be dropped. + sparse : boolean, default=True Will return sparse matrix if set True else will return an array. @@ -205,7 +216,13 @@ class OneHotEncoder(_BaseEncoder): categories_ : list of arrays The categories of each feature determined during fitting (in order of the features in X and corresponding with the output - of ``transform``). + of ``transform``). This includes the category specified in ``drop`` + (if any). + + drop_idx_ : array of shape (n_features,) + ``drop_idx_[i]`` is the index in ``categories_[i]`` of the category to + be dropped for each feature. None if all the transformed features will + be retained. active_features_ : array Indices for active features, meaning values that actually occur @@ -243,9 +260,9 @@ class OneHotEncoder(_BaseEncoder): >>> enc.fit(X) ... # doctest: +ELLIPSIS ... # doctest: +NORMALIZE_WHITESPACE - OneHotEncoder(categorical_features=None, categories=None, - dtype=<... 'numpy.float64'>, handle_unknown='ignore', - n_values=None, sparse=True) + OneHotEncoder(categorical_features=None, categories=None, drop=None, + dtype=<... 'numpy.float64'>, handle_unknown='ignore', + n_values=None, sparse=True) >>> enc.categories_ [array(['Female', 'Male'], dtype=object), array([1, 2, 3], dtype=object)] @@ -257,6 +274,12 @@ class OneHotEncoder(_BaseEncoder): [None, 2]], dtype=object) >>> enc.get_feature_names() array(['x0_Female', 'x0_Male', 'x1_1', 'x1_2', 'x1_3'], dtype=object) + >>> drop_enc = OneHotEncoder(drop='first').fit(X) + >>> drop_enc.categories_ + [array(['Female', 'Male'], dtype=object), array([1, 2, 3], dtype=object)] + >>> drop_enc.transform([['Female', 1], ['Male', 2]]).toarray() + array([[0., 0., 0.], + [1., 1., 0.]]) See also -------- @@ -274,7 +297,7 @@ class OneHotEncoder(_BaseEncoder): """ def __init__(self, n_values=None, categorical_features=None, - categories=None, sparse=True, dtype=np.float64, + categories=None, drop=None, sparse=True, dtype=np.float64, handle_unknown='error'): self.categories = categories self.sparse = sparse @@ -282,6 +305,7 @@ def __init__(self, n_values=None, categorical_features=None, self.handle_unknown = handle_unknown self.n_values = n_values self.categorical_features = categorical_features + self.drop = drop # Deprecated attributes @@ -346,7 +370,6 @@ def _handle_deprecations(self, X): ) warnings.warn(msg, DeprecationWarning) else: - # check if we have integer or categorical input try: check_array(X, dtype=np.int) @@ -354,20 +377,38 @@ def _handle_deprecations(self, X): self._legacy_mode = False self._categories = 'auto' else: - msg = ( - "The handling of integer data will change in version " - "0.22. Currently, the categories are determined " - "based on the range [0, max(values)], while in the " - "future they will be determined based on the unique " - "values.\nIf you want the future behaviour and " - "silence this warning, you can specify " - "\"categories='auto'\".\n" - "In case you used a LabelEncoder before this " - "OneHotEncoder to convert the categories to integers, " - "then you can now use the OneHotEncoder directly." - ) - warnings.warn(msg, FutureWarning) - self._legacy_mode = True + if self.drop is None: + msg = ( + "The handling of integer data will change in " + "version 0.22. Currently, the categories are " + "determined based on the range " + "[0, max(values)], while in the future they " + "will be determined based on the unique " + "values.\nIf you want the future behaviour " + "and silence this warning, you can specify " + "\"categories='auto'\".\n" + "In case you used a LabelEncoder before this " + "OneHotEncoder to convert the categories to " + "integers, then you can now use the " + "OneHotEncoder directly." + ) + warnings.warn(msg, FutureWarning) + self._legacy_mode = True + else: + msg = ( + "The handling of integer data will change in " + "version 0.22. Currently, the categories are " + "determined based on the range " + "[0, max(values)], while in the future they " + "will be determined based on the unique " + "values.\n The old behavior is not compatible " + "with the `drop` parameter. Instead, you " + "must manually specify \"categories='auto'\" " + "if you wish to use the `drop` parameter on " + "an array of entirely integer data. This will " + "enable the future behavior." + ) + raise ValueError(msg) # if user specified categorical_features -> always use legacy mode if self.categorical_features is not None: @@ -399,6 +440,13 @@ def _handle_deprecations(self, X): else: self._categorical_features = 'all' + # Prevents new drop functionality from being used in legacy mode + if self._legacy_mode and self.drop is not None: + raise ValueError( + "The `categorical_features` and `n_values` keywords " + "are deprecated, and cannot be used together " + "with 'drop'.") + def fit(self, X, y=None): """Fit OneHotEncoder to X. @@ -411,10 +459,8 @@ def fit(self, X, y=None): ------- self """ - if self.handle_unknown not in ('error', 'ignore'): - msg = ("handle_unknown should be either 'error' or 'ignore', " - "got {0}.".format(self.handle_unknown)) - raise ValueError(msg) + + self._validate_keywords() self._handle_deprecations(X) @@ -425,8 +471,59 @@ def fit(self, X, y=None): return self else: self._fit(X, handle_unknown=self.handle_unknown) + self.drop_idx_ = self._compute_drop_idx() return self + def _compute_drop_idx(self): + if self.drop is None: + return None + elif (isinstance(self.drop, str) and self.drop == 'first'): + return np.zeros(len(self.categories_), dtype=np.int_) + elif not isinstance(self.drop, str): + try: + self.drop = np.asarray(self.drop, dtype=object) + droplen = len(self.drop) + except (ValueError, TypeError): + msg = ("Wrong input for parameter `drop`. Expected " + "'first', None or array of objects, got {}") + raise ValueError(msg.format(type(self.drop))) + if droplen != len(self.categories_): + msg = ("`drop` should have length equal to the number " + "of features ({}), got {}") + raise ValueError(msg.format(len(self.categories_), + len(self.drop))) + missing_drops = [(i, val) for i, val in enumerate(self.drop) + if val not in self.categories_[i]] + if any(missing_drops): + msg = ("The following categories were supposed to be " + "dropped, but were not found in the training " + "data.\n{}".format( + "\n".join( + ["Category: {}, Feature: {}".format(c, v) + for c, v in missing_drops]))) + raise ValueError(msg) + return np.array([np.where(cat_list == val)[0][0] + for (val, cat_list) in + zip(self.drop, self.categories_)], dtype=np.int_) + else: + msg = ("Wrong input for parameter `drop`. Expected " + "'first', None or array of objects, got {}") + raise ValueError(msg.format(type(self.drop))) + + def _validate_keywords(self): + if self.handle_unknown not in ('error', 'ignore'): + msg = ("handle_unknown should be either 'error' or 'ignore', " + "got {0}.".format(self.handle_unknown)) + raise ValueError(msg) + # If we have both dropped columns and ignored unknown + # values, there will be ambiguous cells. This creates difficulties + # in interpreting the model. + if self.drop is not None and self.handle_unknown != 'error': + raise ValueError( + "`handle_unknown` must be 'error' when the drop parameter is " + "specified, as both would create categories that are all " + "zero.") + def _legacy_fit_transform(self, X): """Assumes X contains only categorical features.""" dtype = getattr(X, 'dtype', None) @@ -501,10 +598,8 @@ def fit_transform(self, X, y=None): X_out : sparse matrix if sparse=True else a 2-d array Transformed input. """ - if self.handle_unknown not in ('error', 'ignore'): - msg = ("handle_unknown should be either 'error' or 'ignore', " - "got {0}.".format(self.handle_unknown)) - raise ValueError(msg) + + self._validate_keywords() self._handle_deprecations(X) @@ -571,11 +666,22 @@ def _transform_new(self, X): X_int, X_mask = self._transform(X, handle_unknown=self.handle_unknown) + if self.drop is not None: + to_drop = self.drop_idx_.reshape(1, -1) + + # We remove all the dropped categories from mask, and decrement all + # categories that occur after them to avoid an empty column. + + keep_cells = X_int != to_drop + X_mask &= keep_cells + X_int[X_int > to_drop] -= 1 + n_values = [len(cats) - 1 for cats in self.categories_] + else: + n_values = [len(cats) for cats in self.categories_] + mask = X_mask.ravel() - n_values = [cats.shape[0] for cats in self.categories_] n_values = np.array([0] + n_values) feature_indices = np.cumsum(n_values) - indices = (X_int + feature_indices[:-1]).ravel()[mask] indptr = X_mask.sum(axis=1).cumsum() indptr = np.insert(indptr, 0, 0) @@ -613,7 +719,7 @@ def transform(self, X): def inverse_transform(self, X): """Convert the back data to the original representation. - In case unknown categories are encountered (all zero's in the + In case unknown categories are encountered (all zeros in the one-hot encoding), ``None`` is used to represent this category. Parameters @@ -635,7 +741,12 @@ def inverse_transform(self, X): n_samples, _ = X.shape n_features = len(self.categories_) - n_transformed_features = sum([len(cats) for cats in self.categories_]) + if self.drop is None: + n_transformed_features = sum(len(cats) + for cats in self.categories_) + else: + n_transformed_features = sum(len(cats) - 1 + for cats in self.categories_) # validate shape of passed X msg = ("Shape of the passed X data is not correct. Expected {0} " @@ -651,18 +762,35 @@ def inverse_transform(self, X): found_unknown = {} for i in range(n_features): - n_categories = len(self.categories_[i]) + if self.drop is None: + cats = self.categories_[i] + else: + cats = np.delete(self.categories_[i], self.drop_idx_[i]) + n_categories = len(cats) + + # Only happens if there was a column with a unique + # category. In this case we just fill the column with this + # unique category value. + if n_categories == 0: + X_tr[:, i] = self.categories_[i][self.drop_idx_[i]] + j += n_categories + continue sub = X[:, j:j + n_categories] - # for sparse X argmax returns 2D matrix, ensure 1D array labels = np.asarray(_argmax(sub, axis=1)).flatten() - X_tr[:, i] = self.categories_[i][labels] - + X_tr[:, i] = cats[labels] if self.handle_unknown == 'ignore': - # ignored unknown categories: we have a row of all zero's unknown = np.asarray(sub.sum(axis=1) == 0).flatten() + # ignored unknown categories: we have a row of all zero if unknown.any(): found_unknown[i] = unknown + # drop will either be None or handle_unknown will be error. If + # self.drop is not None, then we can safely assume that all of + # the nulls in each column are the dropped value + elif self.drop is not None: + dropped = np.asarray(sub.sum(axis=1) == 0).flatten() + if dropped.any(): + X_tr[dropped, i] = self.categories_[i][self.drop_idx_[i]] j += n_categories

diff --git a/sklearn/preprocessing/tests/test_encoders.py b/sklearn/preprocessing/tests/test_encoders.py index 93b1de018d2e9..2734e61128beb 100644 --- a/sklearn/preprocessing/tests/test_encoders.py +++ b/sklearn/preprocessing/tests/test_encoders.py @@ -96,6 +96,20 @@ def test_one_hot_encoder_sparse(): enc.fit([[0], [1]]) assert_raises(ValueError, enc.transform, [[0], [-1]]) + with ignore_warnings(category=(DeprecationWarning, FutureWarning)): + enc = OneHotEncoder(drop='first', n_values=1) + for method in (enc.fit, enc.fit_transform): + assert_raises_regex( + ValueError, + 'The `categorical_features` and `n_values` keywords ', + method, [[0], [-1]]) + + enc = OneHotEncoder(drop='first', categorical_features='all') + assert_raises_regex( + ValueError, + 'The `categorical_features` and `n_values` keywords ', + method, [[0], [-1]]) + def test_one_hot_encoder_dense(): # check for sparse=False @@ -278,7 +292,7 @@ def test_one_hot_encoder_no_categorical_features(): enc = OneHotEncoder(categorical_features=cat) with ignore_warnings(category=(DeprecationWarning, FutureWarning)): X_tr = enc.fit_transform(X) - expected_features = np.array(list(), dtype='object') + expected_features = np.array([], dtype='object') assert_array_equal(X, X_tr) assert_array_equal(enc.get_feature_names(), expected_features) assert enc.categories_ == [] @@ -373,21 +387,25 @@ def test_one_hot_encoder(X): assert_allclose(Xtr.toarray(), [[0, 1, 1, 0, 1], [1, 0, 0, 1, 1]]) -def test_one_hot_encoder_inverse(): - for sparse_ in [True, False]: - X = [['abc', 2, 55], ['def', 1, 55], ['abc', 3, 55]] - enc = OneHotEncoder(sparse=sparse_) - X_tr = enc.fit_transform(X) - exp = np.array(X, dtype=object) - assert_array_equal(enc.inverse_transform(X_tr), exp) +@pytest.mark.parametrize('sparse_', [False, True]) +@pytest.mark.parametrize('drop', [None, 'first']) +def test_one_hot_encoder_inverse(sparse_, drop): + X = [['abc', 2, 55], ['def', 1, 55], ['abc', 3, 55]] + enc = OneHotEncoder(sparse=sparse_, drop=drop) + X_tr = enc.fit_transform(X) + exp = np.array(X, dtype=object) + assert_array_equal(enc.inverse_transform(X_tr), exp) - X = [[2, 55], [1, 55], [3, 55]] - enc = OneHotEncoder(sparse=sparse_, categories='auto') - X_tr = enc.fit_transform(X) - exp = np.array(X) - assert_array_equal(enc.inverse_transform(X_tr), exp) + X = [[2, 55], [1, 55], [3, 55]] + enc = OneHotEncoder(sparse=sparse_, categories='auto', + drop=drop) + X_tr = enc.fit_transform(X) + exp = np.array(X) + assert_array_equal(enc.inverse_transform(X_tr), exp) + if drop is None: # with unknown categories + # drop is incompatible with handle_unknown=ignore X = [['abc', 2, 55], ['def', 1, 55], ['abc', 3, 55]] enc = OneHotEncoder(sparse=sparse_, handle_unknown='ignore', categories=[['abc', 'def'], [1, 2], @@ -407,10 +425,10 @@ def test_one_hot_encoder_inverse(): exp[:, 1] = None assert_array_equal(enc.inverse_transform(X_tr), exp) - # incorrect shape raises - X_tr = np.array([[0, 1, 1], [1, 0, 1]]) - msg = re.escape('Shape of the passed X data is not correct') - assert_raises_regex(ValueError, msg, enc.inverse_transform, X_tr) + # incorrect shape raises + X_tr = np.array([[0, 1, 1], [1, 0, 1]]) + msg = re.escape('Shape of the passed X data is not correct') + assert_raises_regex(ValueError, msg, enc.inverse_transform, X_tr) @pytest.mark.parametrize("X, cat_exp, cat_dtype", [ @@ -687,3 +705,90 @@ def test_one_hot_encoder_warning(): enc = OneHotEncoder() X = [['Male', 1], ['Female', 3]] np.testing.assert_no_warnings(enc.fit_transform, X) + + +def test_one_hot_encoder_drop_manual(): + cats_to_drop = ['def', 12, 3, 56] + enc = OneHotEncoder(drop=cats_to_drop) + X = [['abc', 12, 2, 55], + ['def', 12, 1, 55], + ['def', 12, 3, 56]] + trans = enc.fit_transform(X).toarray() + exp = [[1, 0, 1, 1], + [0, 1, 0, 1], + [0, 0, 0, 0]] + assert_array_equal(trans, exp) + dropped_cats = [cat[feature] + for cat, feature in zip(enc.categories_, + enc.drop_idx_)] + assert_array_equal(dropped_cats, cats_to_drop) + assert_array_equal(np.array(X, dtype=object), + enc.inverse_transform(trans)) + + +def test_one_hot_encoder_invalid_params(): + enc = OneHotEncoder(drop='second') + assert_raises_regex( + ValueError, + "Wrong input for parameter `drop`.", + enc.fit, [["Male"], ["Female"]]) + + enc = OneHotEncoder(handle_unknown='ignore', drop='first') + assert_raises_regex( + ValueError, + "`handle_unknown` must be 'error'", + enc.fit, [["Male"], ["Female"]]) + + enc = OneHotEncoder(drop='first') + assert_raises_regex( + ValueError, + "The handling of integer data will change in version", + enc.fit, [[1], [2]]) + + enc = OneHotEncoder(drop='first', categories='auto') + assert_no_warnings(enc.fit_transform, [[1], [2]]) + + enc = OneHotEncoder(drop=np.asarray('b', dtype=object)) + assert_raises_regex( + ValueError, + "Wrong input for parameter `drop`.", + enc.fit, [['abc', 2, 55], ['def', 1, 55], ['def', 3, 59]]) + + enc = OneHotEncoder(drop=['ghi', 3, 59]) + assert_raises_regex( + ValueError, + "The following categories were supposed", + enc.fit, [['abc', 2, 55], ['def', 1, 55], ['def', 3, 59]]) + + +@pytest.mark.parametrize('drop', [['abc', 3], ['abc', 3, 41, 'a']]) +def test_invalid_drop_length(drop): + enc = OneHotEncoder(drop=drop) + assert_raises_regex( + ValueError, + "`drop` should have length equal to the number", + enc.fit, [['abc', 2, 55], ['def', 1, 55], ['def', 3, 59]]) + + +@pytest.mark.parametrize("density", [True, False], + ids=['sparse', 'dense']) +@pytest.mark.parametrize("drop", ['first', + ['a', 2, 'b']], + ids=['first', 'manual']) +def test_categories(density, drop): + ohe_base = OneHotEncoder(sparse=density) + ohe_test = OneHotEncoder(sparse=density, drop=drop) + X = [['c', 1, 'a'], + ['a', 2, 'b']] + ohe_base.fit(X) + ohe_test.fit(X) + assert_array_equal(ohe_base.categories_, ohe_test.categories_) + if drop == 'first': + assert_array_equal(ohe_test.drop_idx_, 0) + else: + for drop_cat, drop_idx, cat_list in zip(drop, + ohe_test.drop_idx_, + ohe_test.categories_): + assert cat_list[drop_idx] == drop_cat + assert isinstance(ohe_test.drop_idx_, np.ndarray) + assert ohe_test.drop_idx_.dtype == np.int_

diff --git a/doc/modules/preprocessing.rst b/doc/modules/preprocessing.rst index 77abe294a331b..7b7c447beb34d 100644 --- a/doc/modules/preprocessing.rst +++ b/doc/modules/preprocessing.rst @@ -489,7 +489,7 @@ Continuing the example above:: >>> enc = preprocessing.OneHotEncoder() >>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']] >>> enc.fit(X) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - OneHotEncoder(categorical_features=None, categories=None, + OneHotEncoder(categorical_features=None, categories=None, drop=None, dtype=<... 'numpy.float64'>, handle_unknown='error', n_values=None, sparse=True) >>> enc.transform([['female', 'from US', 'uses Safari'], @@ -516,7 +516,7 @@ dataset:: >>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']] >>> enc.fit(X) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE OneHotEncoder(categorical_features=None, - categories=[...], + categories=[...], drop=None, dtype=<... 'numpy.float64'>, handle_unknown='error', n_values=None, sparse=True) >>> enc.transform([['female', 'from Asia', 'uses Chrome']]).toarray() @@ -533,13 +533,31 @@ columns for this feature will be all zeros >>> enc = preprocessing.OneHotEncoder(handle_unknown='ignore') >>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']] >>> enc.fit(X) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE - OneHotEncoder(categorical_features=None, categories=None, + OneHotEncoder(categorical_features=None, categories=None, drop=None, dtype=<... 'numpy.float64'>, handle_unknown='ignore', n_values=None, sparse=True) >>> enc.transform([['female', 'from Asia', 'uses Chrome']]).toarray() array([[1., 0., 0., 0., 0., 0.]]) +It is also possible to encode each column into ``n_categories - 1`` columns +instead of ``n_categories`` columns by using the ``drop`` parameter. This +parameter allows the user to specify a category for each feature to be dropped. +This is useful to avoid co-linearity in the input matrix in some classifiers. +Such functionality is useful, for example, when using non-regularized +regression (:class:`LinearRegression <sklearn.linear_model.LinearRegression>`), +since co-linearity would cause the covariance matrix to be non-invertible. +When this paramenter is not None, ``handle_unknown`` must be set to +``error``:: + + >>> X = [['male', 'from US', 'uses Safari'], ['female', 'from Europe', 'uses Firefox']] + >>> drop_enc = preprocessing.OneHotEncoder(drop='first').fit(X) + >>> drop_enc.categories_ + [array(['female', 'male'], dtype=object), array(['from Europe', 'from US'], dtype=object), array(['uses Firefox', 'uses Safari'], dtype=object)] + >>> drop_enc.transform(X).toarray() + array([[1., 1., 1.], + [0., 0., 0.]]) + See :ref:`dict_feature_extraction` for categorical features that are represented as a dict, not as scalars. diff --git a/doc/whats_new/v0.21.rst b/doc/whats_new/v0.21.rst index 36582d834c708..f828c17a0c5fe 100644 --- a/doc/whats_new/v0.21.rst +++ b/doc/whats_new/v0.21.rst @@ -278,6 +278,11 @@ Support for Python 3.4 and below has been officially dropped. :class:`preprocessing.StandardScaler`. :issue:`13007` by :user:`Raffaello Baluyot <baluyotraf>` +- |Feature| :class:`OneHotEncoder` now supports dropping one feature per category + with a new drop parameter. :issue:`12908` by + :user:`Drew Johnston <drewmjohnston>`. + + :mod:`sklearn.tree` ................... - |Feature| Decision Trees can now be plotted with matplotlib using

[ { "components": [ { "doc": "", "lines": [ 477, 511 ], "name": "OneHotEncoder._compute_drop_idx", "signature": "def _compute_drop_idx(self):", "type": "function" }, { "doc": "", "lines": [ 513, ...

[ "sklearn/preprocessing/tests/test_encoders.py::test_one_hot_encoder_sparse", "sklearn/preprocessing/tests/test_encoders.py::test_one_hot_encoder_inverse[None-False]", "sklearn/preprocessing/tests/test_encoders.py::test_one_hot_encoder_inverse[None-True]", "sklearn/preprocessing/tests/test_encoders.py::test_on...

[ "sklearn/preprocessing/tests/test_encoders.py::test_one_hot_encoder_dense", "sklearn/preprocessing/tests/test_encoders.py::test_one_hot_encoder_deprecationwarnings", "sklearn/preprocessing/tests/test_encoders.py::test_one_hot_encoder_force_new_behaviour", "sklearn/preprocessing/tests/test_encoders.py::test_on...

This is a feature request which requires a new feature to add in the code repository. <<NEW FEATURE REQUEST>> <request> [MRG + 2] Add Drop Option to OneHotEncoder. #### Reference Issues/PRs Fixes #6488 and fixes #6053. This builds upon some of the code from #12884 (thanks @NicolasHug!), but also incorporates functionality which lets the user manually specify which category in each column they would like to be dropped, so this is a more general solution along the lines of what @amueller suggested in #6053. This is useful in some cases (such as OLS regression) where the dropped group affects the interpretation of coefficients. This should also fix #9361, which has less functionality and appears stalled. #### What does this implement/fix? Explain your changes. This code implements a new parameter (drop) in the OneHotEncoder, which can take any of three values: None (default), which implements the existing behavior. 'first', which drops the first value in each category. list of length n_features, which allows for the manual specification of the reference group. #### Any other comments? This new feature does not work in Legacy mode (this was discussed in #6053), and it requires the manual specification of "categories='auto'" in the case in which the input is all integers, so as not to interfere with the ongoing change in the treatment of integers in OneHotEncoder. This code is also incompatible with "handle_missing='ignore'", since in that case it is not possible to determine which categories are 0 because they are in the reference category and which are all 0 due to missing data. Closes #12884 ---------- </request> There are several new functions or classes that need to be implemented, using the definitions below: <<NEW DEFINITIONS>> There are several new functions or classes that need to be implemented, using the definitions below: <definitions> [start of new definitions in sklearn/preprocessing/_encoders.py] (definition of OneHotEncoder._compute_drop_idx:) def _compute_drop_idx(self): (definition of OneHotEncoder._validate_keywords:) def _validate_keywords(self): [end of new definitions in sklearn/preprocessing/_encoders.py] </definitions> Please note that in addition to the newly added components mentioned above, you also need to make other code changes to ensure that the new feature can be executed properly. <<END>>

Here is the discussion in the issues of the pull request. <issues> OneHotEncoder - add option for 1 of k-1 encoding Like the title says. Would it be possible to add an option, say "independent = True" to OneHotEncoder that would return a 1 of k-1 encoding instead of a 1 of k encoding. This would be very useful to me when I am encoding categorical variables since the 1 of k encoding adds an extra (non-independent) degree of freedom to the model. It would also be nice if I could specify which category to keep as the baseline. Something like: ``` X = np.array([12,24,36]).reshape(-1,1) OneHotEncoder(sparse=False, independent=True, baseline=24).fit_transform(X) Output: array([[ 1., 0.], [ 0., 0.], [ 0., 1.]]) ``` ---------- I guess we could do that as many people ask about it. I don't think there is that much of a point in doing that. Nearly all the models in scikit-learn are regularized, so this doesn't matter afaik. I guess you are using a linear model? @vighneshbirodkar is working on the `OneHotEncoder`, it might be worth waiting till that is finished. Yup. I'm using a linear regression on categorical variables. So actually no regularization. The regression works fine so there must be a fix for collinearity (non invertibility) in `scipy.linalg.lstsq` but I find this way of building a model a bit confusing. The solution to the least squared problem with collinearity is under determined - there is a family of solutions. And so to solve it there is some behind the scenes choice being made as to _the_ solution which is hidden from the user. Basically I'd rather not introduce collinearity into a model that will then have to deal with that collinearity. This is all obviously just my under informed opinion :) Why are you not using regularization? I think the main reason people don't use regularization is that they want simple statistics on the coefficients. But scikit-learn doesn't provide any statistics of the coefficients. Maybe statsmodels would be a better fit for your application. If you are interested in predictive performance, just replace `LinearRegression` with `RidgeCV` and your predictions will improve. Ok. I guess regularization is the way to go in scikit-learn. I do still disagree in that I think dependence shouldn't be introduced into the model by way of preprocessors (or at least there should be an option to turn this off). But maybe this is getting at the difference between machine learning and statistical modelling. Or maybe who cares about independence if we have regularization. Sorry for the slow reply. I'm ok with adding an option to turn this off. But as I said, OneHotEncoder is still being refactored. I've elsewhere discussed similar for `LabelBinarizer` in the multiclass case, proposing the parameter name `drop_first` to ignore the encoding of the smallest value. --------------------OneHotEncoding - Defining a reference category In order to avoid multicollinearity in modelling, the number of dummy-coded variables needed should be one less than the number of categories. Therefore, it would be very code if OneHotEncoding could accept a reference category as an input variable. ---------- not sure if that was raise somewhere already. multicollinearity is really not a problem in any model in scikit-learn. But feel free to create a pull-request. The OneHotEncoder is being restructured quite heavily right now, though. I'm interested in working on this feature! I ran into some problems using a OneHotEncoder in a pipeline that used a Keras Neural Network as the classifier. I was attempting to transform a few columns of categorical features into a dummy variable representation and feed the resulting columns (plus some numerical variables that were passed through) into the NN for classification. However, the one hot encoding played poorly with the collinear columns, and my model performed poorly out of sample. I was eventually able to design a workaround, but it seems to me that it would be valuable to have a tool in scikit-learn that could do this simply. I see the above pull request, which began to implement this in the DictVectorizer class, but it looks like this was never implemented (probably due to some unresolved fixes that were suggested). Is there anything stopping this from being implemented in the OneHotEncoder case instead? I think we'd accept a PR. I'm a bit surprised there's none yet. We also changed the OneHotEncoder quite a bit recently. You probably don't want to modify the "legacy" mode. A question is whether/how we allow users to specify which category to drop. In regularized models this actually makes a difference IIRC. We could have a parameter ``drop`` that's ``'none'`` by default, and could be ``'first'`` or a datastructure with the values to drop. could be a list/numpy array of length n_features (all input features are categorical in the new OneHotEncoder). Reading through the comments on the old PR, I was thinking that those options seem to be the natural choice. I'm in the midst of graduate school applications right now so my time is somewhat limited, but this seems to be something that is going to keep appearing in my work, so I'm going to have to address this (or keep using workarounds) at some point. On Wed, Nov 28, 2018 at 3:49 PM Andreas Mueller <notifications@github.com> wrote: > I think we'd accept a PR. I'm a bit surprised there's none yet. We also > changed the OneHotEncoder quite a bit recently. You probably don't want to > modify the "legacy" mode. A question is whether/how we allow users to > specify which category to drop. In regularized models this actually makes a > difference IIRC. > We could have a parameter drop that's 'none' by default, and could be > 'first' or a datastructure with the values to drop. could be a list/numpy > array of length n_features (all input features are categorical in the new > OneHotEncoder). > > — > You are receiving this because you commented. > Reply to this email directly, view it on GitHub > <https://github.com/scikit-learn/scikit-learn/issues/6053#issuecomment-442599181>, > or mute the thread > <https://github.com/notifications/unsubscribe-auth/Am4ucQaSxhMTVGCeWx4cy-xx5Xl3EHmOks5uzvbugaJpZM4G2bMF> > . > --------------------[MRG] ENH: add support for dropping first level of categorical feature #### Reference Issues Fixes #6053 Fixes #9073 #### What does this implement/fix? Explain your changes. This Pull Request adds an extra argument to `DictVectorizer` that, if set to `True`, drops the first level of each categorical variable. This is extremely useful in a regression model that to not use regularisation, as it avoids multicollinearity. #### Any other comments Even though multicollinearity doesn't affect the predictions, it hugely affects the regression coefficients, which makes troublesome both model inspection and further usage of such coefficients. ---------- @jnothman are you happy with the changes I made? Feel free to leave additional comments if you find something that can be improved. I'm hoping to start working on some new bug fix as soon as this weekend. I think you'd best adopt something like my approach. Imagine someone analysing the most stable important features under control validation. If the feature dropped differs for each cv split, the results are uninterpretable On 21 Jul 2017 6:43 am, "Gianluca Rossi" <notifications@github.com> wrote: *@IamGianluca* commented on this pull request. ------------------------------ In sklearn/feature_extraction/dict_vectorizer.py <https://github.com/scikit-learn/scikit-learn/pull/9361#discussion_r128625938> : > for x in X: for f, v in six.iteritems(x): if isinstance(v, six.string_types): + if self.drop_first_category and f not in to_drop: Hi Joel, I like your solution! I've intentionally avoided splitting the string using a separator to overcome issues of ambiguity ― I hope people don't ever use the = character in columns names, but you never know :-) Let me know if you want me to implement your suggestion, and I'll update my PR. I also fear this is too sensitive to the ordering of the data for the user to find it explicable. That's a valid point. In my own project to overcome such problem, I've stored the dictionaries that I want to pass to DictVectorizer inside a "master" dictionary. This master dictionary has keys that can be sorted in a way that guarantees the first category is deterministic. x = vectorizer.fit_transform([v for k, v in sorted(master.items())]) In this example a key in master could be something like the following tuple: (582498109, 'Desktop') ... where Desktop is the level I want to drop, and each id (the first element in the tuple) is associated with multiple devices, such as Tablet, Mobile, etc. I appreciate this is specific to my use case and not always true. To be entirely fair, as a Data Scientist, 99% of the times you don't really care about which category is being dropped since that is simply your baseline. I guess in those situations when you need a specific category to be dropped, you can always build your own sorting function to pass to the key argument in sorted. What do you think? — You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub <https://github.com/scikit-learn/scikit-learn/pull/9361#discussion_r128625938>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AAEz6_FXTJlr9yn4TatzsLy6RkFc1lgfks5sP7vogaJpZM4OYxec> . --------------------[MRG] add drop_first option to OneHotEncoder  #### Reference Issues/PRs  Closes #6488 #### What does this implement/fix? Explain your changes. This PR adds a `drop_first` option to `OneHotEncoder`. Each feature is encoded into `n_unique_values - 1` columns instead of `n_unique_values` columns. The first one is dropped, resulting in all of the others being zero. #### Any other comments? This is incompatible with `handle_missing='ignore'` because the ignored missing categories result in all of the one-hot columns being zeros, which is also how the first category is treated when `drop_first=True`. So by allowing both, there would be no way to distinguish between a missing category and the first one.  ---------- -------------------- </issues>

66cc1c7342f7f0cc0dc57fb6d56053fc46c8e5f0