Lines Matching refs:step
20 PyObject *step;
24 /* Helper function for validating step. Always returns a new reference or
28 validate_step(PyObject *step)
30 /* No step specified, use a step of 1. */
31 if (!step)
34 step = PyNumber_Index(step);
35 if (step && _PyLong_Sign(step) == 0) {
38 Py_CLEAR(step);
41 return step;
45 compute_range_length(PyObject *start, PyObject *stop, PyObject *step);
49 PyObject *stop, PyObject *step)
53 length = compute_range_length(start, stop, step);
64 obj->step = step;
78 PyObject *start = NULL, *stop = NULL, *step = NULL;
82 step = args[2];
95 step = validate_step(step); /* Caution, this can clear exceptions */
96 if (!step) {
109 step = _PyLong_GetOne();
110 Py_INCREF(step);
122 obj = make_range_object(type, start, stop, step);
130 Py_DECREF(step);
157 range(start, stop[, step]) -> range object\n\
160 to stop (exclusive) by step. range(i, j) produces i, i+1, i+2, ..., j-1.\n\
163 When step is given, it specifies the increment (or decrement).");
170 Py_DECREF(r->step);
175 /* Return number of items in range (lo, hi, step) as a PyLong object,
180 compute_range_length(PyObject *start, PyObject *stop, PyObject *step)
195 cmp_result = PyObject_RichCompareBool(step, zero, Py_GT);
202 Py_INCREF(step);
206 step = PyNumber_Negative(step);
207 if (!step)
214 Py_DECREF(step);
228 if ((tmp2 = PyNumber_FloorDivide(diff, step)) == NULL)
236 Py_DECREF(step);
241 Py_DECREF(step);
259 * return r->start + (i * r->step)
261 if (r->step == _PyLong_GetOne()) {
265 incr = PyNumber_Multiply(i, r->step);
345 PyObject *start = NULL, *stop = NULL, *step = NULL;
349 error = _PySlice_GetLongIndices(slice, r->length, &start, &stop, &step);
353 substep = PyNumber_Multiply(r->step, step);
355 Py_CLEAR(step);
372 Py_XDECREF(step);
391 cmp1 = PyObject_RichCompareBool(r->step, zero, Py_GT);
414 tmp2 = PyNumber_Remainder(tmp1, r->step);
417 /* result = ((int(ob) - start) % step) == 0 */
448 return r0.step == r1.step
473 return PyObject_RichCompareBool(r0->step, r1->step, Py_EQ);
512 return hash((len(r), r.start, r.step))
546 Py_INCREF(r->step);
547 PyTuple_SET_ITEM(t, 2, r->step);
596 if (r->step == _PyLong_GetOne()) {
600 /* idx = (ob - r.start) // r.step */
601 PyObject *sidx = PyNumber_FloorDivide(idx, r->step);
628 need the step value. We don't care about overflow. */
629 istep = PyNumber_AsSsize_t(r->step, NULL);
639 r->start, r->stop, r->step);
647 r->start, r->stop, r->step);
712 {"step", T_OBJECT_EX, offsetof(rangeobject, step), READONLY},
769 long step;
780 (unsigned long)(r->index++) * r->step));
796 PyObject *start=NULL, *stop=NULL, *step=NULL;
803 stop = PyLong_FromLong(r->start + r->len * r->step);
806 step = PyLong_FromLong(r->step);
807 if (step == NULL)
810 start, stop, step);
819 Py_XDECREF(step);
884 /* Return number of items in range (lo, hi, step). step != 0
888 get_len_of_range(long lo, long hi, long step)
891 If step > 0 and lo >= hi, or step < 0 and lo <= hi, the range is empty.
892 Else for step > 0, if n values are in the range, the last one is
893 lo + (n-1)*step, which must be <= hi-1. Rearranging,
894 n <= (hi - lo - 1)/step + 1, so taking the floor of the RHS gives
900 precision to compute the RHS exactly. The analysis for step < 0
903 assert(step != 0);
904 if (step > 0 && lo < hi)
905 return 1UL + (hi - 1UL - lo) / step;
906 else if (step < 0 && lo > hi)
907 return 1UL + (lo - 1UL - hi) / (0UL - step);
916 fast_range_iter(long start, long stop, long step, long len)
922 it->step = step;
932 PyObject *step;
949 product = PyNumber_Multiply(r->len, r->step);
957 Py_INCREF(r->step);
959 r->start, stop, r->step);
963 Py_DECREF(r->step);
1012 Py_XDECREF(r->step);
1028 product = PyNumber_Multiply(r->index, r->step);
1101 lstep = PyLong_AsLong(r->step);
1129 it->step = r->step;
1133 Py_INCREF(it->step);
1150 /* reversed(range(start, stop, step)) can be expressed as
1151 range(start+(n-1)*step, start-step, -step), where n is the number of
1154 If each of start, stop, step, -step, start-step, and the length
1170 lstep = PyLong_AsLong(range->step);
1213 it->index = it->start = it->step = NULL;
1215 /* start + (len - 1) * step */
1223 product = PyNumber_Multiply(diff, range->step);
1234 it->step = PyNumber_Negative(range->step);
1235 if (!it->step)