Python numpy.isneginf() Examples

The following are 30 code examples for showing how to use numpy.isneginf(). These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example.

You may check out the related API usage on the sidebar.

You may also want to check out all available functions/classes of the module numpy , or try the search function .

Example 1
Project: scattertext   Author: JasonKessler   File: Scalers.py    License: Apache License 2.0 6 votes vote down vote up
def scale_neg_1_to_1_with_zero_mean_log_abs_max(v):
	'''
	!!! not working
	'''
	df = pd.DataFrame({'v':v,
	                   'sign': (v > 0) * 2 - 1})
	df['lg'] = np.log(np.abs(v)) / np.log(1.96)
	df['exclude'] = (np.isinf(df.lg) | np.isneginf(df.lg))
	for mask in [(df['sign'] == -1) & (df['exclude'] == False),
	             (df['sign'] == 1) & (df['exclude'] == False)]:
		df[mask]['lg'] = df[mask]['lg'].max() - df[mask]['lg']
	df['lg'] *= df['sign']
	df['lg'] = df['lg'].fillna(0)
	print(df[df['exclude']]['lg'].values)
	#to_rescale = convention_df['lg'].reindex(v.index)
	df['to_out'] =  scale_neg_1_to_1_with_zero_mean_abs_max(df['lg'])
	print('right')
	print(df.sort_values(by='lg').iloc[:5])
	print(df.sort_values(by='lg').iloc[-5:])
	print('to_out')
	print(df.sort_values(by='to_out').iloc[:5])
	print(df.sort_values(by='to_out').iloc[-5:])
	print(len(df), len(df.dropna()))
	return df['to_out'] 
Example 2
Project: onnx-tensorflow   Author: onnx   File: test_node.py    License: Apache License 2.0 6 votes vote down vote up
def test_is_inf(self):
    if legacy_opset_pre_ver(10):
      raise unittest.SkipTest("ONNX version {} doesn't support IsInf.".format(
          defs.onnx_opset_version()))
    input = np.array([-1.2, np.nan, np.inf, 2.8, np.NINF, np.inf],
                     dtype=np.float32)
    expected_output = {
        "node_def": np.isinf(input),
        "node_def_neg_false": np.isposinf(input),
        "node_def_pos_false": np.isneginf(input)
    }
    node_defs = {
        "node_def":
            helper.make_node("IsInf", ["X"], ["Y"]),
        "node_def_neg_false":
            helper.make_node("IsInf", ["X"], ["Y"], detect_negative=0),
        "node_def_pos_false":
            helper.make_node("IsInf", ["X"], ["Y"], detect_positive=0)
    }
    for key in node_defs:
      output = run_node(node_defs[key], [input])
      np.testing.assert_equal(output["Y"], expected_output[key]) 
Example 3
Project: sparse   Author: pydata   File: common.py    License: BSD 3-Clause "New" or "Revised" License 6 votes vote down vote up
def isneginf(x, out=None):
    """
    Test element-wise for negative infinity, return result as sparse ``bool`` array.

    Parameters
    ----------
    x
        Input
    out, optional
        Output array

    Examples
    --------
    >>> import sparse
    >>> x = sparse.as_coo(np.array([-np.inf]))
    >>> sparse.isneginf(x).todense()
    array([ True])

    See Also
    --------
    numpy.isneginf : The NumPy equivalent
    """
    from .core import elemwise

    return elemwise(lambda x, out=None, dtype=None: np.isneginf(x, out=out), x, out=out) 
Example 4
Project: factorized   Author: pliang279   File: data_loader.py    License: MIT License 6 votes vote down vote up
def load_covarep(truth_dict):
    for video_index in truth_dict:
        file_name = covarep_path + video_index + '.mat'
        fts = sio.loadmat(file_name)['features']
        #print fts.shape
        for seg_index in truth_dict[video_index]:
            for w in truth_dict[video_index][seg_index]['data']:
                start_frame = int(w['start_time_clip']*100)
                end_frame = int(w['end_time_clip']*100)
                ft = fts[start_frame:end_frame]
                if ft.shape[0] == 0:
                    avg_ft = np.zeros(ft.shape[1])
                else:
                    #print np.array(ft).shape
                    #print ft[0]
                    avg_ft = np.mean(ft,0)
                avg_ft[np.isnan(avg_ft)] = 0
                avg_ft[np.isneginf(avg_ft)] = 0
                w['covarep'] = avg_ft 
Example 5
Project: cooltools   Author: mirnylab   File: numutils.py    License: MIT License 6 votes vote down vote up
def fill_inf(arr, pos_value=0, neg_value=0, copy=True):
    """Replaces positive and negative infinity entries in an array with the
    provided values.

    Parameters
    ----------
    arr : np.array

    pos_value : float
        Fill value for np.inf

    neg_value : float
        Fill value for -np.inf

    copy : bool, optional
        If True, creates a copy of x, otherwise replaces values in-place.
        By default, True.

    """
    if copy:
        arr = arr.copy()
    arr[np.isposinf(arr)] = pos_value
    arr[np.isneginf(arr)] = neg_value
    return arr 
Example 6
Project: DNGR-Keras   Author: MdAsifKhan   File: DNGR.py    License: MIT License 6 votes vote down vote up
def PPMI_matrix(M):

	M = scale_sim_mat(M)
	nm_nodes = len(M)

	col_s = np.sum(M, axis=0).reshape(1,nm_nodes)
	row_s = np.sum(M, axis=1).reshape(nm_nodes,1)
	D = np.sum(col_s)
	rowcol_s = np.dot(row_s,col_s)
	PPMI = np.log(np.divide(D*M,rowcol_s))
	PPMI[np.isnan(PPMI)] = 0.0
	PPMI[np.isinf(PPMI)] = 0.0
	PPMI[np.isneginf(PPMI)] = 0.0
	PPMI[PPMI<0] = 0.0

	return PPMI 
Example 7
Project: MFN   Author: pliang279   File: data_loader.py    License: MIT License 6 votes vote down vote up
def load_covarep(truth_dict):
    for video_index in truth_dict:
        file_name = covarep_path + video_index + '.mat'
        fts = sio.loadmat(file_name)['features']
        #print fts.shape
        for seg_index in truth_dict[video_index]:
            for w in truth_dict[video_index][seg_index]['data']:
                start_frame = int(w['start_time_clip']*100)
                end_frame = int(w['end_time_clip']*100)
                ft = fts[start_frame:end_frame]
                if ft.shape[0] == 0:
                    avg_ft = np.zeros(ft.shape[1])
                else:
                    #print np.array(ft).shape
                    #print ft[0]
                    avg_ft = np.mean(ft,0)
                avg_ft[np.isnan(avg_ft)] = 0
                avg_ft[np.isneginf(avg_ft)] = 0
                w['covarep'] = avg_ft 
Example 8
Project: gluon-ts   Author: awslabs   File: util.py    License: Apache License 2.0 6 votes vote down vote up
def jsonify_floats(json_object):
    """
    Traverses through the JSON object and converts non JSON-spec compliant
    floats(nan, -inf, inf) to their string representations.

    Parameters
    ----------
    json_object
        JSON object
    """
    if isinstance(json_object, dict):
        return {k: jsonify_floats(v) for k, v in json_object.items()}
    elif isinstance(json_object, list):
        return [jsonify_floats(item) for item in json_object]
    elif isinstance(json_object, float):
        if np.isnan(json_object):
            return "NaN"
        elif np.isposinf(json_object):
            return "Infinity"
        elif np.isneginf(json_object):
            return "-Infinity"
        return json_object
    return json_object 
Example 9
Project: Carnets   Author: holzschu   File: converters.py    License: BSD 3-Clause "New" or "Revised" License 6 votes vote down vote up
def output(self, value, mask):
        if mask:
            return self._null_output
        if np.isfinite(value):
            if not np.isscalar(value):
                value = value.dtype.type(value)
            result = self._output_format.format(value)
            if result.startswith('array'):
                raise RuntimeError()
            if (self._output_format[2] == 'r' and
                result.endswith('.0')):
                result = result[:-2]
            return result
        elif np.isnan(value):
            return 'NaN'
        elif np.isposinf(value):
            return '+InF'
        elif np.isneginf(value):
            return '-InF'
        # Should never raise
        vo_raise(f"Invalid floating point value '{value}'") 
Example 10
Project: tensorprob   Author: tensorprob   File: utilities.py    License: MIT License 5 votes vote down vote up
def set_logp_to_neg_inf(X, logp, bounds):
    """Set `logp` to negative infinity when `X` is outside the allowed bounds.

    # Arguments
        X: tensorflow.Tensor
            The variable to apply the bounds to
        logp: tensorflow.Tensor
            The log probability corrosponding to `X`
        bounds: list of `Region` objects
            The regions corrosponding to allowed regions of `X`

    # Returns
        logp: tensorflow.Tensor
            The newly bounded log probability
    """
    conditions = []
    for l, u in bounds:
        lower_is_neg_inf = not isinstance(l, tf.Tensor) and np.isneginf(l)
        upper_is_pos_inf = not isinstance(u, tf.Tensor) and np.isposinf(u)

        if not lower_is_neg_inf and upper_is_pos_inf:
            conditions.append(tf.greater(X, l))
        elif lower_is_neg_inf and not upper_is_pos_inf:
            conditions.append(tf.less(X, u))
        elif not (lower_is_neg_inf or upper_is_pos_inf):
            conditions.append(tf.logical_and(tf.greater(X, l), tf.less(X, u)))

    if len(conditions) > 0:
        is_inside_bounds = conditions[0]
        for condition in conditions[1:]:
            is_inside_bounds = tf.logical_or(is_inside_bounds, condition)

        logp = tf.select(
            is_inside_bounds,
            logp,
            tf.fill(tf.shape(X), config.dtype(-np.inf))
        )

    return logp 
Example 11
Project: vnpy_crypto   Author: birforce   File: test_stattools.py    License: MIT License 5 votes vote down vote up
def test_coint_identical_series():
    nobs = 200
    scale_e = 1
    np.random.seed(123)
    y = scale_e * np.random.randn(nobs)
    warnings.simplefilter('always', ColinearityWarning)
    with warnings.catch_warnings(record=True) as w:
        c = coint(y, y, trend="c", maxlag=0, autolag=None)
    assert_equal(len(w), 1)
    assert_equal(c[1], 0.0)
    assert_(np.isneginf(c[0])) 
Example 12
Project: vnpy_crypto   Author: birforce   File: test_stattools.py    License: MIT License 5 votes vote down vote up
def test_coint_perfect_collinearity():
    # test uses nearly perfect collinearity
    nobs = 200
    scale_e = 1
    np.random.seed(123)
    x = scale_e * np.random.randn(nobs, 2)
    y = 1 + x.sum(axis=1) + 1e-7 * np.random.randn(nobs)
    warnings.simplefilter('always', ColinearityWarning)
    with warnings.catch_warnings(record=True) as w:
        c = coint(y, x, trend="c", maxlag=0, autolag=None)
    assert_equal(c[1], 0.0)
    assert_(np.isneginf(c[0])) 
Example 13
Project: vnpy_crypto   Author: birforce   File: test_tost.py    License: MIT License 5 votes vote down vote up
def assert_almost_equal_inf(x, y, decimal=6, msg=None):
    x = np.atleast_1d(x)
    y = np.atleast_1d(y)
    assert_equal(np.isposinf(x), np.isposinf(y))
    assert_equal(np.isneginf(x), np.isneginf(y))
    assert_equal(np.isnan(x), np.isnan(y))
    assert_almost_equal(x[np.isfinite(x)], y[np.isfinite(y)]) 
Example 14
Project: gordo   Author: equinor   File: test_transformers.py    License: GNU Affero General Public License v3.0 5 votes vote down vote up
def test_infimputer_fill_values():
    """
    InfImputer when fill values are provided
    """
    base_x = np.random.random((100, 10)).astype(np.float32)

    flat_view = base_x.ravel()

    pos_inf_idxs = [1, 2, 3, 4, 5]
    neg_inf_idxs = [6, 7, 8, 9, 10]

    flat_view[pos_inf_idxs] = np.inf
    flat_view[neg_inf_idxs] = -np.inf

    # Our base x should now be littered with pos/neg inf values
    assert np.isposinf(base_x).sum() > 0, "Expected some positive infinity values here"
    assert np.isneginf(base_x).sum() > 0, "Expected some negative infinity values here"

    imputer = InfImputer(inf_fill_value=9999.0, neg_inf_fill_value=-9999.0)
    X = imputer.fit_transform(base_x)
    np.equal(
        X.ravel()[[pos_inf_idxs]], np.array([9999.0, 9999.0, 9999.0, 9999.0, 9999.0])
    )
    np.equal(
        X.ravel()[[neg_inf_idxs]],
        np.array([-9999.0, -9999.0, -9999.0, -9999.0, -9999.0]),
    ) 
Example 15
Project: gordo   Author: equinor   File: imputer.py    License: GNU Affero General Public License v3.0 5 votes vote down vote up
def transform(self, X: Union[pd.DataFrame, np.ndarray], y=None):

        # Ensure we're dealing with numpy array if it's a dataframe or similar
        X = X.values if hasattr(X, "values") else X

        # Apply specific fill values if provided.
        if self.inf_fill_value is not None:
            X[np.isposinf(X)] = self.inf_fill_value
        if self.neg_inf_fill_value is not None:
            X[np.isneginf(X)] = self.neg_inf_fill_value

        # May still be left over infs, if only one fill value was supplied for example
        if self.strategy is not None:
            return getattr(self, f"_fill_{self.strategy}")(X)
        return X 
Example 16
Project: gordo   Author: equinor   File: imputer.py    License: GNU Affero General Public License v3.0 5 votes vote down vote up
def _fill_extremes(self, X: np.ndarray):
        """
        Fill negative and postive infs with their dtype's min/max values
        """
        X[np.isposinf(X)] = np.finfo(X.dtype).max
        X[np.isneginf(X)] = np.finfo(X.dtype).min
        return X 
Example 17
Project: gordo   Author: equinor   File: imputer.py    License: GNU Affero General Public License v3.0 5 votes vote down vote up
def _fill_minmax(self, X: np.ndarray):
        """
        Fill inf/-inf values in features of the array based on their min & max values.
        Compounded by the ``power`` value so long as the result doesn't exceed the
        current array's dtype's max/min. Otherwise it will use those.
        """

        # For each feature fill inf/-inf with pre-calculate fill values
        for feature_idx, (posinf_fill, neginf_fill) in enumerate(
            zip(self._posinf_fill_values, self._neginf_fill_values)
        ):
            X[:, feature_idx][np.isposinf(X[:, feature_idx])] = posinf_fill
            X[:, feature_idx][np.isneginf(X[:, feature_idx])] = neginf_fill
        return X 
Example 18
Project: Computable   Author: ktraunmueller   File: nanops.py    License: MIT License 5 votes vote down vote up
def _has_infs(result):
    if isinstance(result, np.ndarray):
        if result.dtype == 'f8':
            return lib.has_infs_f8(result)
        elif result.dtype == 'f4':
            return lib.has_infs_f4(result)
        return False
    return np.isinf(result) or np.isneginf(result) 
Example 19
Project: smooth-topk   Author: oval-group   File: utils.py    License: MIT License 5 votes vote down vote up
def assert_all_close(tensor_1, tensor_2, rtol=1e-4, atol=1e-4):
    tensor_1 = to_numpy(tensor_1).astype(np.float64)
    tensor_2 = to_numpy(tensor_2).astype(np.float64)
    np.testing.assert_equal(np.isposinf(tensor_1),
                            np.isposinf(tensor_2))
    np.testing.assert_equal(np.isneginf(tensor_1),
                            np.isneginf(tensor_2))
    indices = np.isfinite(tensor_1)
    if indices.sum():
        tensor_1 = tensor_1[indices]
        tensor_2 = tensor_2[indices]
        err = np.max(np.abs(tensor_1 - tensor_2))
        err_msg = "Max abs error: {0:.3g}".format(err)
        np.testing.assert_allclose(tensor_1, tensor_2, rtol=rtol, atol=atol,
                                   err_msg=err_msg) 
Example 20
Project: trax   Author: google   File: math_ops.py    License: Apache License 2.0 5 votes vote down vote up
def isneginf(x):
  return x == array_ops.full_like(x, -np.inf) 
Example 21
Project: GraphicDesignPatternByPython   Author: Relph1119   File: test_distributions.py    License: MIT License 5 votes vote down vote up
def test_x_inf(self):
        # make sure x=inf is handled gracefully
        rv = stats.genpareto(c=0.1)
        assert_allclose([rv.pdf(np.inf), rv.cdf(np.inf)], [0., 1.])
        assert_(np.isneginf(rv.logpdf(np.inf)))

        rv = stats.genpareto(c=0.)
        assert_allclose([rv.pdf(np.inf), rv.cdf(np.inf)], [0., 1.])
        assert_(np.isneginf(rv.logpdf(np.inf)))

        rv = stats.genpareto(c=-1.)
        assert_allclose([rv.pdf(np.inf), rv.cdf(np.inf)], [0., 1.])
        assert_(np.isneginf(rv.logpdf(np.inf))) 
Example 22
Project: GraphicDesignPatternByPython   Author: Relph1119   File: test_distributions.py    License: MIT License 5 votes vote down vote up
def test_ncx2_tails_pdf():
    # ncx2.pdf does not return nans in extreme tails(example from gh-1577)
    # NB: this is to check that nan_to_num is not needed in ncx2.pdf
    with suppress_warnings() as sup:
        sup.filter(RuntimeWarning, "divide by zero encountered in log")
        assert_equal(stats.ncx2.pdf(1, np.arange(340, 350), 2), 0)
        logval = stats.ncx2.logpdf(1, np.arange(340, 350), 2)

    assert_(np.isneginf(logval).all()) 
Example 23
Project: cupy   Author: cupy   File: test_erf.py    License: MIT License 5 votes vote down vote up
def test_erfinv_behavior(self, dtype):
        a = cupy.empty((1,), dtype=dtype)

        a[:] = 1.0 + 1E-6
        a = cupyx.scipy.special.erfinv(a)
        assert cupy.isnan(a)
        a[:] = -1.0 - 1E-6
        a = cupyx.scipy.special.erfinv(a)
        assert cupy.isnan(a)
        a[:] = 1.0
        a = cupyx.scipy.special.erfinv(a)
        assert numpy.isposinf(cupy.asnumpy(a))
        a[:] = -1.0
        a = cupyx.scipy.special.erfinv(a)
        assert numpy.isneginf(cupy.asnumpy(a)) 
Example 24
Project: cupy   Author: cupy   File: test_erf.py    License: MIT License 5 votes vote down vote up
def test_erfcinv_behavior(self, dtype):
        a = cupy.empty((1,), dtype=dtype)

        a[:] = 2.0 + 1E-6
        a = cupyx.scipy.special.erfcinv(a)
        assert cupy.isnan(a)
        a[:] = 0.0 - 1E-6
        a = cupyx.scipy.special.erfcinv(a)
        assert cupy.isnan(a)
        a[:] = 0.0
        a = cupyx.scipy.special.erfcinv(a)
        assert numpy.isposinf(cupy.asnumpy(a))
        a[:] = 2.0
        a = cupyx.scipy.special.erfcinv(a)
        assert numpy.isneginf(cupy.asnumpy(a)) 
Example 25
Project: mljar-supervised   Author: mljar   File: terminate_on_nan.py    License: MIT License 5 votes vote down vote up
def on_iteration_end(self, iter_cnt, data):
        loss_train = 0
        if data.get("y_train_predicted") is not None:
            loss_train = self.metric(
                data.get("y_train_true"), data.get("y_train_predicted")
            )
        loss_validation = self.metric(
            data.get("y_validation_true"), data.get("y_validation_predicted")
        )

        for loss in [loss_train, loss_validation]:
            if np.isnan(loss) or np.isinf(loss) or np.isneginf(loss):
                self.learner.stop_training = True
                log.info("Terminating learning, invalid loss value") 
Example 26
Project: madminer   Author: diana-hep   File: various.py    License: MIT License 5 votes vote down vote up
def sanitize_array(array, replace_nan=0.0, replace_inf=0.0, replace_neg_inf=0.0, min_value=None, max_value=None):
    array[np.isneginf(array)] = replace_neg_inf
    array[np.isinf(array)] = replace_inf
    array[np.isnan(array)] = replace_nan

    if min_value is not None or max_value is not None:
        array = np.clip(array, min_value, max_value)

    return array 
Example 27
Project: scvelo   Author: theislab   File: rank_velocity_genes.py    License: BSD 3-Clause "New" or "Revised" License 5 votes vote down vote up
def get_mean_var(X, ignore_zeros=False, perc=None):
    data = X.data if issparse(X) else X
    mask_nans = np.isnan(data) | np.isinf(data) | np.isneginf(data)

    n_nonzeros = (X != 0).sum(0)
    n_counts = n_nonzeros if ignore_zeros else X.shape[0]

    if mask_nans.sum() > 0:
        if issparse(X):
            data[np.isnan(data) | np.isinf(data) | np.isneginf(data)] = 0
            n_nans = n_nonzeros - (X != 0).sum(0)
        else:
            X[mask_nans] = 0
            n_nans = mask_nans.sum(0)
        n_counts -= n_nans

    if perc is not None:
        if np.size(perc) < 2:
            perc = [perc, 100] if perc < 50 else [0, perc]
        lb, ub = np.percentile(data, perc)
        data = np.clip(data, lb, ub)

    if issparse(X):
        mean = (X.sum(0) / n_counts).A1
        mean_sq = (X.multiply(X).sum(0) / n_counts).A1
    else:
        mean = X.sum(0) / n_counts
        mean_sq = np.multiply(X, X).sum(0) / n_counts
    n_cells = np.clip(X.shape[0], 2, None)  # to avoid division by zero
    var = (mean_sq - mean ** 2) * (n_cells / (n_cells - 1))

    mean = np.nan_to_num(mean)
    var = np.nan_to_num(var)
    return mean, var 
Example 28
Project: scvelo   Author: theislab   File: utils.py    License: BSD 3-Clause "New" or "Revised" License 5 votes vote down vote up
def get_mean_var(X, ignore_zeros=False, perc=None):
    data = X.data if issparse(X) else X
    mask_nans = np.isnan(data) | np.isinf(data) | np.isneginf(data)

    n_nonzeros = (X != 0).sum(0)
    n_counts = n_nonzeros if ignore_zeros else X.shape[0]

    if mask_nans.sum() > 0:
        if issparse(X):
            data[np.isnan(data) | np.isinf(data) | np.isneginf(data)] = 0
            n_nans = n_nonzeros - (X != 0).sum(0)
        else:
            X[mask_nans] = 0
            n_nans = mask_nans.sum(0)
        n_counts -= n_nans

    if perc is not None:
        if np.size(perc) < 2:
            perc = [perc, 100] if perc < 50 else [0, perc]
        lb, ub = np.percentile(data, perc)
        data = np.clip(data, lb, ub)

    if issparse(X):
        mean = (X.sum(0) / n_counts).A1
        mean_sq = (X.multiply(X).sum(0) / n_counts).A1
    else:
        mean = X.sum(0) / n_counts
        mean_sq = np.multiply(X, X).sum(0) / n_counts
    n_cells = np.clip(X.shape[0], 2, None)  # to avoid division by zero
    var = (mean_sq - mean ** 2) * (n_cells / (n_cells - 1))

    mean = np.nan_to_num(mean)
    var = np.nan_to_num(var)
    return mean, var 
Example 29
Project: Neuraxle   Author: Neuraxio   File: distributions.py    License: Apache License 2.0 5 votes vote down vote up
def min(self):
        """
        Calculate minimum value that can be sampled in the quanitzed version of the distribution.

        :return: minimal value return from distribution.
        """
        hd_min = self.hd.min()
        if np.isneginf(hd_min):
            return hd_min
        return round(hd_min) 
Example 30
Project: Neuraxle   Author: Neuraxio   File: distributions.py    License: Apache License 2.0 5 votes vote down vote up
def _get_sum_starting_info(limits):
    if np.isinf(limits[0]) and np.isinf(limits[1]):
        raise ValueError("Cannot calculate a sum on infinite terms.")
    if np.isposinf(limits[0]):
        starting_value = limits[1]
        stop_value = limits[0]
        method = "increasing"
    elif np.isposinf(limits[1]):
        starting_value = limits[0]
        stop_value = limits[1]
        method = "increasing"
    elif np.isneginf(limits[0]):
        starting_value = limits[1]
        stop_value = limits[0]
        method = "decreasing"
    elif np.isneginf(limits[1]):
        starting_value = limits[0]
        stop_value = limits[1]
        method = "decreasing"
    elif np.greater(limits[1], limits[0]):
        starting_value = limits[0]
        stop_value = limits[1]
        method = "increasing"
    else:
        starting_value = limits[1]
        stop_value = limits[0]
        method = "increasing"
    return method, starting_value, stop_value