def valid(self, model, blamelist=False, pairs=True, \ all=False, raw=False, **kwds): """check for validity with respect to given model Args: model (func): the model function, ``y' = F(x')``. blamelist (bool, default=False): if True, indicate the infeasible points. pairs (bool, default=True): if True, indicate indices of infeasible points. all (bool, default=False): if True, get results for each individual point. raw (bool, default=False): if False, get boolean results (i.e. non-float). ytol (float, default=0.0): maximum acceptable difference ``|y - F(x')|``. xtol (float, default=0.0): maximum acceptable difference ``|x - x'|``. cutoff (float, default=ytol): zero out distances less than cutoff. hausdorff (bool, default=False): hausdorff ``norm``, where if given, then ``ytol = |y - F(x')| + |x - x'|/norm``. Notes: *xtol* defines the n-dimensional base of a pilar of height *ytol*, centered at each point. The region inside the pilar defines the space where a "valid" model must intersect. If *xtol* is not specified, then the base of the pilar will be a dirac at ``x' = x``. This function performs an optimization for each ``x`` to find an appropriate ``x'``. *ytol* is a single value, while *xtol* is a single value or an iterable. *cutoff* takes a float or a boolean, where ``cutoff=True`` will set the value of *cutoff* to the default. Typically, the value of *cutoff* is *ytol*, 0.0, or None. *hausdorff* can be False (e.g. ``norm = 1.0``), True (e.g. ``norm = spread(x)``), or a list of points of ``len(x)``. While *cutoff* and *ytol* are very tightly related, they play a distinct role; *ytol* is used to set the optimization termination for an acceptable ``|y - F(x')|``, while *cutoff* is applied post-optimization. If we are using the *hausdorff* norm, then *ytol* will set the optimization termination for an acceptable ``|y - F(x')| + |x - x'|/norm``, where the ``x`` values are normalized by ``norm = hausdorff``. """ ytol = kwds['ytol'] if 'ytol' in kwds else 0.0 # get tolerance in y # default is to zero out distances less than tolerance cutoff = kwds['cutoff'] if 'cutoff' in kwds else ytol if cutoff is True: cutoff = ytol elif cutoff is False: cutoff = None from mystic.math.distance import graphical_distance, is_feasible # calculate the model validity Rv = graphical_distance(model, self, **kwds) ld = is_feasible(Rv, cutoff) if raw: x = Rv else: x = ld if not blamelist: return ld.all() if not all else x if pairs: return _fails(ld) # else lookup failures return _fails(ld, self)
def short(self, data=None, L=None, blamelist=False, pairs=True, all=False, raw=False, **kwds): """check for shortness with respect to given data (or self) Inputs: data -- a collection of data points (if None, use the dataset itself) L -- the lipschitz constant, if different from that of the dataset itself blamelist -- if True, report which points are infeasible pairs -- if True, report indices of infeasible points all -- if True, report results for each point (opposed to all points) raw -- if True, report numerical results (opposed to boolean results) Additional Inputs: tol -- maximum acceptable deviation from shortness cutoff -- zero out distances less than cutoff; typically: tol, 0.0, or None Notes: Each point x,y can be thought to have an associated double-cone with slope equal to the lipschitz constant. Shortness with respect to another point is defined by the first point not being inside the cone of the second. We can allow for some error in shortness, a short tolerance 'tol', for which the point x,y is some acceptable y-distance inside the cone. While very tightly related, cutoff and tol play distinct roles; tol is subtracted from calculation of the lipschitz_distance, while cutoff zeros out the value of any element less than the cutoff. """ tol = kwds["tol"] if "tol" in kwds else 0.0 # get tolerance in y # default is to zero out distances less than tolerance cutoff = kwds["cutoff"] if "cutoff" in kwds else tol if cutoff is True: cutoff = tol elif cutoff is False: cutoff = None if L is None: L = self.lipschitz if data is None: data = self from mystic.math.distance import lipschitz_distance, is_feasible # calculate the shortness Rv = lipschitz_distance(L, self, data, **kwds) ld = is_feasible(Rv, cutoff) if raw: x = Rv else: x = ld if not blamelist: return ld.all() if not all else x if pairs: return _fails(ld) # else lookup failures return _fails(ld, data)
def valid(self, model, blamelist=False, pairs=True, all=False, raw=False, **kwds): """check for validity with respect to given model Inputs: model -- the model function, y' = F(x') blamelist -- if True, report which points are infeasible pairs -- if True, report indices of infeasible points all -- if True, report results for each point (opposed to all points) raw -- if True, report numerical results (opposed to boolean results) Additional Inputs: ytol -- maximum acceptable difference |y - F(x')|; a single value xtol -- maximum acceptable difference |x - x'|; an iterable or single value cutoff -- zero out distances less than cutoff; typically: ytol, 0.0, or None hausdorff -- norm; where if given, ytol = |y - F(x')| + |x - x'|/norm Notes: xtol defines the n-dimensional base of a pilar of height ytol, centered at each point. The region inside the pilar defines the space where a "valid" model must intersect. If xtol is not specified, then the base of the pilar will be a dirac at x' = x. This function performs an optimization for each x to find an appropriate x'. While cutoff and ytol are very tightly related, they play a distinct role; ytol is used to set the optimization termination for an acceptable |y - F(x')|, while cutoff is applied post-optimization. If we are using the hausdorff norm, then ytol will set the optimization termination for an acceptable |y - F(x')| + |x - x'|/norm, where the x values are normalized by norm = hausdorff. """ ytol = kwds["ytol"] if "ytol" in kwds else 0.0 # get tolerance in y # default is to zero out distances less than tolerance cutoff = kwds["cutoff"] if "cutoff" in kwds else ytol if cutoff is True: cutoff = ytol elif cutoff is False: cutoff = None from mystic.math.distance import graphical_distance, is_feasible # calculate the model validity Rv = graphical_distance(model, self, **kwds) ld = is_feasible(Rv, cutoff) if raw: x = Rv else: x = ld if not blamelist: return ld.all() if not all else x if pairs: return _fails(ld) # else lookup failures return _fails(ld, self)
def valid(self, model, blamelist=False, pairs=True, \ all=False, raw=False, **kwds): """check for validity with respect to given model Inputs: model -- the model function, y' = F(x') blamelist -- if True, report which points are infeasible pairs -- if True, report indicies of infeasible points all -- if True, report results for each point (opposed to all points) raw -- if True, report numerical results (opposed to boolean results) Additional Inputs: ytol -- maximum acceptable difference |y - F(x')|; a single value xtol -- maximum acceptable difference |x - x'|; an iterable or single value cutoff -- zero out distances less than cutoff; typically: ytol, 0.0, or None hausdorff -- norm; where if given, ytol = |y - F(x')| + |x - x'|/norm Notes: xtol defines the n-dimensional base of a pilar of height ytol, centered at each point. The region inside the pilar defines the space where a "valid" model must intersect. If xtol is not specified, then the base of the pilar will be a dirac at x' = x. This function performs an optimization for each x to find an appropriate x'. While cutoff and ytol are very tightly related, they play a distinct role; ytol is used to set the optimization termination for an acceptable |y - F(x')|, while cutoff is applied post-optimization. If we are using the hausdorff norm, then ytol will set the optimization termination for an acceptable |y - F(x')| + |x - x'|/norm, where the x values are normalized by norm = hausdorff. """ ytol = kwds['ytol'] if 'ytol' in kwds else 0.0 # get tolerance in y # default is to zero out distances less than tolerance cutoff = kwds['cutoff'] if 'cutoff' in kwds else ytol if cutoff is True: cutoff = ytol elif cutoff is False: cutoff = None from mystic.math.distance import graphical_distance, is_feasible # calculate the model validity Rv = graphical_distance(model, self, **kwds) ld = is_feasible(Rv, cutoff) if raw: x = Rv else: x = ld if not blamelist: return ld.all() if not all else x if pairs: return _fails(ld) # else lookup failures return _fails(ld, self)
def short(self, data=None, L=None, blamelist=False, pairs=True, \ all=False, raw=False, **kwds): """check for shortness with respect to given data (or self) Inputs: data -- a collection of data points (if None, use the dataset itself) L -- the lipschitz constant, if different from that of the dataset itself blamelist -- if True, report which points are infeasible pairs -- if True, report indicies of infeasible points all -- if True, report results for each point (opposed to all points) raw -- if True, report numerical results (opposed to boolean results) Additional Inputs: tol -- maximum acceptable deviation from shortness cutoff -- zero out distances less than cutoff; typically: tol, 0.0, or None Notes: Each point x,y can be thought to have an associated double-cone with slope equal to the lipschitz constant. Shortness with respect to another point is defined by the first point not being inside the cone of the second. We can allow for some error in shortness, a short tolerance 'tol', for which the point x,y is some acceptable y-distance inside the cone. While very tightly related, cutoff and tol play distinct roles; tol is subtracted from calculation of the lipschitz_distance, while cutoff zeros out the value of any element less than the cutoff. """ tol = kwds['tol'] if 'tol' in kwds else 0.0 # get tolerance in y # default is to zero out distances less than tolerance cutoff = kwds['cutoff'] if 'cutoff' in kwds else tol if cutoff is True: cutoff = tol elif cutoff is False: cutoff = None if L is None: L = self.lipschitz if data is None: data = self from mystic.math.distance import lipschitz_distance, is_feasible # calculate the shortness Rv = lipschitz_distance(L, self, data, **kwds) ld = is_feasible(Rv, cutoff) if raw: x = Rv else: x = ld if not blamelist: return ld.all() if not all else x if pairs: return _fails(ld) # else lookup failures return _fails(ld, data)
def short(self, data=None, L=None, blamelist=False, pairs=True, \ all=False, raw=False, **kwds): """check for shortness with respect to given data (or self) Args: data (list, default=None): a list of data points, or the dataset itself. L (float, default=None): the lipschitz constant, or the dataset's constant. blamelist (bool, default=False): if True, indicate the infeasible points. pairs (bool, default=True): if True, indicate indices of infeasible points. all (bool, default=False): if True, get results for each individual point. raw (bool, default=False): if False, get boolean results (i.e. non-float). tol (float, default=0.0): maximum acceptable deviation from shortness. cutoff (float, default=tol): zero out distances less than cutoff. Notes: Each point x,y can be thought to have an associated double-cone with slope equal to the lipschitz constant. Shortness with respect to another point is defined by the first point not being inside the cone of the second. We can allow for some error in shortness, a short tolerance *tol*, for which the point x,y is some acceptable y-distance inside the cone. While very tightly related, *cutoff* and *tol* play distinct roles; *tol* is subtracted from calculation of the lipschitz_distance, while *cutoff* zeros out the value of any element less than the *cutoff*. """ tol = kwds['tol'] if 'tol' in kwds else 0.0 # get tolerance in y # default is to zero out distances less than tolerance cutoff = kwds['cutoff'] if 'cutoff' in kwds else tol if cutoff is True: cutoff = tol elif cutoff is False: cutoff = None if L is None: L = self.lipschitz if data is None: data = self from mystic.math.distance import lipschitz_distance, is_feasible # calculate the shortness Rv = lipschitz_distance(L, self, data, **kwds) ld = is_feasible(Rv, cutoff) if raw: x = Rv else: x = ld if not blamelist: return ld.all() if not all else x if pairs: return _fails(ld) # else lookup failures return _fails(ld, data)