Revision history - ASKSAGE: Sage Q&A Forum

Depending on how sensitive is your map f you should notice that 0.1 is a floating-point approximation of 1/10, which is not equal to 1/10 since the numbers are represented in binary format and that 1/10 can be written as p/2^q for no integers p and q. So, perhaps (depending on you application, speed, accuracy,...) you should use the exact (rational) 1/10 instead of the numerical 0.1.

Sage offers a srange function that produces the list of numbers you want:

sage: srange(1,4, step = 1/10)
[1,
 11/10,
 6/5,
 13/10,
 7/5,
 3/2,
 8/5,
 17/10,
 9/5,
 19/10,
 2,
 21/10,
 11/5,
 23/10,
 12/5,
 5/2,
 13/5,
 27/10,
 14/5,
 29/10,
 3,
 31/10,
 16/5,
 33/10,
 17/5,
 7/2,
 18/5,
 37/10,
 19/5,
 39/10]

To be compared with:

sage: srange(1,4, step = 0.1)
[1.00000000000000,
 1.10000000000000,
 1.20000000000000,
 1.30000000000000,
 1.40000000000000,
 1.50000000000000,
 1.60000000000000,
 1.70000000000000,
 1.80000000000000,
 1.90000000000000,
 2.00000000000000,
 2.10000000000000,
 2.20000000000000,
 2.30000000000000,
 2.40000000000000,
 2.50000000000000,
 2.60000000000000,
 2.70000000000000,
 2.80000000000000,
 2.90000000000000,
 3.00000000000000,
 3.10000000000000,
 3.20000000000000,
 3.30000000000000,
 3.40000000000000,
 3.50000000000000,
 3.60000000000000,
 3.70000000000000,
 3.80000000000000,
 3.90000000000000]

Be careful, that the last value (4 in this case) is not produced.

So, you can get your sum as either:

sage: decimal = 0.1
sage: sum([f(i) for i in srange(1,4+decimal, step=decimal)])

or,

sage: decimal = 1/10
sage: sum([f(i) for i in srange(1,4+decimal, step=decimal)])

In that way, both the lists [f(i) for i in srange(1,4+decimal, step=decimal)] and srange(1,4+decimal, step=decimal) are produced and stored in memory befire the sum is computed. If, instead of 4 you plan to use a very big number, you may want to avoid storing them but only sum them, you can use iterators instead of lists, it suffice to replace srange with xsrange and [...] with (...), so you could write:

sage: sum((f(i) for i in xsrange(1,4+decimal, step=decimal)))

Depending on how sensitive is your map f you should notice that 0.1 is a floating-point approximation of 1/10, which is not equal to 1/10 since the numbers are represented in binary format and that 1/10 can not be written as p/2^q for no some integers p and q. So, perhaps (depending on you application, speed, accuracy,...) you should use the exact (rational) 1/10 instead of the numerical 0.1.

. The following example could be convincing:

sage: decimal = 0.1
sage: sum([decimal for i in  range(10)])
1.00000000000000
sage: sum([decimal for i in  range(10)]) == 1
False

Sage offers a srange function that produces the list of numbers you want:

sage: srange(1,4, step = 1/10)
[1,
 11/10,
 6/5,
 13/10,
 7/5,
 3/2,
 8/5,
 17/10,
 9/5,
 19/10,
 2,
 21/10,
 11/5,
 23/10,
 12/5,
 5/2,
 13/5,
 27/10,
 14/5,
 29/10,
 3,
 31/10,
 16/5,
 33/10,
 17/5,
 7/2,
 18/5,
 37/10,
 19/5,
 39/10]

To be compared with:

sage: srange(1,4, step = 0.1)
[1.00000000000000,
 1.10000000000000,
 1.20000000000000,
 1.30000000000000,
 1.40000000000000,
 1.50000000000000,
 1.60000000000000,
 1.70000000000000,
 1.80000000000000,
 1.90000000000000,
 2.00000000000000,
 2.10000000000000,
 2.20000000000000,
 2.30000000000000,
 2.40000000000000,
 2.50000000000000,
 2.60000000000000,
 2.70000000000000,
 2.80000000000000,
 2.90000000000000,
 3.00000000000000,
 3.10000000000000,
 3.20000000000000,
 3.30000000000000,
 3.40000000000000,
 3.50000000000000,
 3.60000000000000,
 3.70000000000000,
 3.80000000000000,
 3.90000000000000]

Be careful, that the last value (4 in this case) is not produced.

So, you can get your sum as either:

sage: decimal = 0.1
sage: sum([f(i) for i in srange(1,4+decimal, step=decimal)])

or,

sage: decimal = 1/10
sage: sum([f(i) for i in srange(1,4+decimal, step=decimal)])

In that way, both the lists [f(i) for i in srange(1,4+decimal, step=decimal)] and srange(1,4+decimal, step=decimal) are produced and stored in memory befire the sum is computed. If, instead of 4 you plan to use a very big number, you may want to avoid storing them but only sum them, you can use iterators instead of lists, it suffice to replace srange with xsrange and [...] with (...), so you could write:

sage: sum((f(i) for i in xsrange(1,4+decimal, step=decimal)))

Depending on how sensitive is your map f you should notice that 0.1 is a floating-point approximation of 1/10, which is not equal to 1/10 since the numbers are represented in binary format and that 1/10 can not be written as p/2^q for some integers p and q. So, perhaps (depending on ~~you~~ your application, the required speed, the required accuracy,...) you should use the exact (rational) 1/10 instead of the numerical 0.1. The following example could be convincing:

sage: decimal = 0.1
sage: sum([decimal for i in  range(10)])
1.00000000000000
sage: sum([decimal for i in  range(10)]) == 1
False

Sage offers a srange function that produces the list of numbers you want:

sage: srange(1,4, step = 1/10)
[1,
 11/10,
 6/5,
 13/10,
 7/5,
 3/2,
 8/5,
 17/10,
 9/5,
 19/10,
 2,
 21/10,
 11/5,
 23/10,
 12/5,
 5/2,
 13/5,
 27/10,
 14/5,
 29/10,
 3,
 31/10,
 16/5,
 33/10,
 17/5,
 7/2,
 18/5,
 37/10,
 19/5,
 39/10]

To be compared with:

sage: srange(1,4, step = 0.1)
[1.00000000000000,
 1.10000000000000,
 1.20000000000000,
 1.30000000000000,
 1.40000000000000,
 1.50000000000000,
 1.60000000000000,
 1.70000000000000,
 1.80000000000000,
 1.90000000000000,
 2.00000000000000,
 2.10000000000000,
 2.20000000000000,
 2.30000000000000,
 2.40000000000000,
 2.50000000000000,
 2.60000000000000,
 2.70000000000000,
 2.80000000000000,
 2.90000000000000,
 3.00000000000000,
 3.10000000000000,
 3.20000000000000,
 3.30000000000000,
 3.40000000000000,
 3.50000000000000,
 3.60000000000000,
 3.70000000000000,
 3.80000000000000,
 3.90000000000000]

Be careful, that the last value (4 in this case) is not produced.

So, you can get your sum as either:

sage: decimal = 0.1
sage: sum([f(i) for i in srange(1,4+decimal, srange(1, 4+decimal, step=decimal)])

or,

sage: decimal = 1/10
sage: sum([f(i) for i in srange(1,4+decimal, srange(1, 4+decimal, step=decimal)])

In that way, both the lists [f(i) for i in srange(1,4+decimal, step=decimal)] and srange(1,4+decimal, step=decimal) are produced and stored in memory befire the sum is computed. If, instead of 4 you plan to use a very big number, you may want to avoid storing them but only sum them, you can use iterators instead of lists, it suffice to replace srange with xsrange and [...] with (...), so you could write:

sage: sum((f(i) for i in xsrange(1,4+decimal, xsrange(1, 4+decimal, step=decimal)))

Depending on how sensitive is your map f you should notice that 0.1 is a floating-point approximation of 1/10, which is not equal to 1/10 since the numbers are represented in binary format and that 1/10 can not be written as p/2^q for some integers p and q. So, perhaps (depending on your application, the required speed, the required accuracy,...) you should use the exact (rational) 1/10 instead of the numerical 0.1. The following example could be convincing:

sage: decimal = 0.1
sage: sum([decimal for i in  range(10)])
1.00000000000000
sage: sum([decimal for i in  range(10)]) == 1
False

Sage offers a srange function that produces the list of numbers you want:

sage: srange(1,4, step = 1/10)
[1,
 11/10,
 6/5,
 13/10,
 7/5,
 3/2,
 8/5,
 17/10,
 9/5,
 19/10,
 2,
 21/10,
 11/5,
 23/10,
 12/5,
 5/2,
 13/5,
 27/10,
 14/5,
 29/10,
 3,
 31/10,
 16/5,
 33/10,
 17/5,
 7/2,
 18/5,
 37/10,
 19/5,
 39/10]

To be compared with:

sage: srange(1,4, step = 0.1)
[1.00000000000000,
 1.10000000000000,
 1.20000000000000,
 1.30000000000000,
 1.40000000000000,
 1.50000000000000,
 1.60000000000000,
 1.70000000000000,
 1.80000000000000,
 1.90000000000000,
 2.00000000000000,
 2.10000000000000,
 2.20000000000000,
 2.30000000000000,
 2.40000000000000,
 2.50000000000000,
 2.60000000000000,
 2.70000000000000,
 2.80000000000000,
 2.90000000000000,
 3.00000000000000,
 3.10000000000000,
 3.20000000000000,
 3.30000000000000,
 3.40000000000000,
 3.50000000000000,
 3.60000000000000,
 3.70000000000000,
 3.80000000000000,
 3.90000000000000]

Be careful, that the last value (4 in this case) is not ~~produced.~~produced by default. If you want it, you should use the include_endpoint option:

So, you can get your sum as either:

sage: decimal = 0.1
sage: sum([f(i) for i in srange(1, 4+decimal, step=decimal)])
4, step=decimal, include_endpoint=True)])

or,

sage: decimal = 1/10
sage: sum([f(i) for i in srange(1, 4+decimal, step=decimal)])
4, step=decimal, include_endpoint=True)])

In that way, both the lists [f(i) for i in srange(1,4+decimal, step=decimal)]srange(1,4, step=decimal, include_endpoint=True)] and srange(1,4+decimal, step=decimal)srange(1,4, step=decimal, include_endpoint=True) are produced and stored in memory befire the sum is computed. If, instead of 4 you plan to use a very big number, you may want to avoid storing them but only sum them, you can use iterators instead of lists, it suffice to replace srange with xsrange and [...] with (...), so you could write:

sage: sum((f(i) for i in xsrange(1, 4+decimal, step=decimal)))
4, step=decimal, include_endpoint=True)))

Revision history [back]