},"Initializes a BundleSigned from a dict of (good,quantity) pairs")
.def("__getitem__",(constdouble&(BundleSigned::*)(eris_id_t)const)&BundleSigned::operator[],"Accesses the quantity of a given good in the bundle. Returns 0 for goods that are not in the bundle (rather than throwing a KeyError)")
.def("__getitem__",[](BundleSigned&b,MemberIDid){return(double)b[id];},"Accesses the quantity of a given good in the bundle. Returns 0 for goods that are not in the bundle (rather than throwing a KeyError)")
.def("__setitem__",&BundleSigned::set,"Sets the quantity of a given good in the bundle.")
.def("positive",&BundleSigned::positive,"Constructs a new Bundle (not BundleSigned) containing all of the strictly positive quantities of this bundle. Goods with a quantity of 0 are not included.")
.def("negative",&BundleSigned::negative,"Constructs a new Bundle (not BundleSigned) containing all of the strictly negative quantities of this bundle, converted to positive values. Goods with a quantity of 0 are not included.")
.def("zeros",&BundleSigned::zeros,"Constructs a new Bundle (not BundleSigned) containing all of the goods that have quantities of exactly 0. Complementary to positive() and negative()")
"Transfers approximately the given amount between two bundles. Positive quantities in `amount` are transferred from this bundle into `to`; negative quantities are transferred from `to` into this bundle. `epsilon` is a relative threshold: the individual transfer amounts may be adjusted by this times the initial quantity if doing so would result in exactly 0 post-transfer. This is intended to avoid numerical error that could result in small positive of negative quantities. Returns the bundle actually transferred, which can differ slightly from `amount` because of `epsilon`",
"Transfers approximately the given amount in (for positive quantities) or out (for negative quantities) and returns it. Note that, unlike the three-argument transfer_approx method, this method can only apply `epsilon` adjustments to amounts transferred out of the called-upon bundle, and so the other version is much preferred to transfer between bundles.",
.def("transfer_to",&Bundle::transferTo,"Transfers all quantities held by the caller into the target bundle. Essentially the same as `bundle.transfer(bundle, to)` except that `bundle` will always be cleared, while using `transfer` can leave negligible amounts in `bundle`.",
.def("begin_transaction",&BundleSigned::beginTransaction,"Begins a transaction for this bundle, used to ensure that multiple bundle modifications are either entirely succeeded or entirely aborted. While the transaction is in progress, all Bundle changes are stored separately from the pre-transaction values until either abort_transaction() or commit_transaction() is called. If the optional `encompassing` parameter is true, any transactions started during this transaction are effectively ignored",
py::arg("encompassing")=false)
.def("commit_transaction",&BundleSigned::commitTransaction,"Finishes a transaction successfully; the pre-transaction bundle values are discarded.")