Efficient Round edition with different rounding directionWhy round to even integers?How to prevent Round with hided fractionsVery different results from evaluating same expression with different precisionsProblems with rounding giving too many digits

If you attempt to grapple an opponent that you are hidden from, do they roll at disadvantage?

Curses work by shouting - How to avoid collateral damage?

Coordinate position not precise

Greatest common substring

Applicability of Single Responsibility Principle

Do there exist finite commutative rings with identity that are not Bézout rings?

Why are on-board computers allowed to change controls without notifying the pilots?

How can I get through very long and very dry, but also very useful technical documents when learning a new tool?

Understanding "audieritis" in Psalm 94

What to do with wrong results in talks?

Teaching indefinite integrals that require special-casing

Should my PhD thesis be submitted under my legal name?

The plural of 'stomach"

How was Earth single-handedly capable of creating 3 of the 4 gods of chaos?

Can I use my Chinese passport to enter China after I acquired another citizenship?

How does residential electricity work?

What would be the benefits of having both a state and local currencies?

Is expanding the research of a group into machine learning as a PhD student risky?

Time travel short story where a man arrives in the late 19th century in a time machine and then sends the machine back into the past

Trouble understanding overseas colleagues

(Bedrock Edition) Loading more than six chunks at once

Dot above capital letter not centred

Can a monster with multiattack use this ability if they are missing a limb?

Can I Retrieve Email Addresses from BCC?



Efficient Round edition with different rounding direction


Why round to even integers?How to prevent Round with hided fractionsVery different results from evaluating same expression with different precisionsProblems with rounding giving too many digits













1












$begingroup$


As pointed out in this post, Mathematica has a special version of Round that




Round rounds numbers of the form x.5 toward the nearest even integer.




A comment by David G suggest that why not have differnt options Direction → "HalfDown","HalfUp","HalfEven","HalfOdd","Stochastic"



These days I need a version of Round to HalfUp. I write a quite ugly and slow function as below



myRound[x_, d_] := Module[,
c1 = (1./d)*10;
c2 = 1./d;
theDigit = Last@IntegerDigits@IntegerPart[x*c1];
If[theDigit >= 5,
Internal`StringToDouble@ToString@N[(IntegerPart[x*c2] + 1)/c2],
Internal`StringToDouble@ToString@N[(IntegerPart[x*c2])/c2]]]


speed test



In[267]:= 
myRound[#, 0.01] & /@ RandomReal[1., 1000000]; // AbsoluteTiming

Out[267]= 30.7072, Null

In[268]:=
Round[#, 0.01] & /@ RandomReal[1., 1000000]; // AbsoluteTiming

Out[268]= 0.285921, Null


So I am wondering if someone on this site already have developed an efficient toolkit for round matters?










share|improve this question











$endgroup$











  • $begingroup$
    Floor[x+0.5]?
    $endgroup$
    – Szabolcs
    Mar 17 at 11:58










  • $begingroup$
    @Szabolcs But Floor gives integer. Round can round at any digit
    $endgroup$
    – matheorem
    Mar 17 at 12:02






  • 2




    $begingroup$
    Are your aware of RoundingRule?
    $endgroup$
    – Silvia
    Mar 17 at 12:25






  • 1




    $begingroup$
    Could extend the method proposed by @Szabolcs: myRound[x_, d_] := d*Floor[x/d + 1/2]
    $endgroup$
    – Daniel Lichtblau
    Mar 17 at 13:58






  • 1




    $begingroup$
    That's a result of using decimal values e.g. .01 that do not have exact binary equivalents. Could instead do myRound[8.121,1/100] and numericize afterward.
    $endgroup$
    – Daniel Lichtblau
    Mar 17 at 18:36















1












$begingroup$


As pointed out in this post, Mathematica has a special version of Round that




Round rounds numbers of the form x.5 toward the nearest even integer.




A comment by David G suggest that why not have differnt options Direction → "HalfDown","HalfUp","HalfEven","HalfOdd","Stochastic"



These days I need a version of Round to HalfUp. I write a quite ugly and slow function as below



myRound[x_, d_] := Module[,
c1 = (1./d)*10;
c2 = 1./d;
theDigit = Last@IntegerDigits@IntegerPart[x*c1];
If[theDigit >= 5,
Internal`StringToDouble@ToString@N[(IntegerPart[x*c2] + 1)/c2],
Internal`StringToDouble@ToString@N[(IntegerPart[x*c2])/c2]]]


speed test



In[267]:= 
myRound[#, 0.01] & /@ RandomReal[1., 1000000]; // AbsoluteTiming

Out[267]= 30.7072, Null

In[268]:=
Round[#, 0.01] & /@ RandomReal[1., 1000000]; // AbsoluteTiming

Out[268]= 0.285921, Null


So I am wondering if someone on this site already have developed an efficient toolkit for round matters?










share|improve this question











$endgroup$











  • $begingroup$
    Floor[x+0.5]?
    $endgroup$
    – Szabolcs
    Mar 17 at 11:58










  • $begingroup$
    @Szabolcs But Floor gives integer. Round can round at any digit
    $endgroup$
    – matheorem
    Mar 17 at 12:02






  • 2




    $begingroup$
    Are your aware of RoundingRule?
    $endgroup$
    – Silvia
    Mar 17 at 12:25






  • 1




    $begingroup$
    Could extend the method proposed by @Szabolcs: myRound[x_, d_] := d*Floor[x/d + 1/2]
    $endgroup$
    – Daniel Lichtblau
    Mar 17 at 13:58






  • 1




    $begingroup$
    That's a result of using decimal values e.g. .01 that do not have exact binary equivalents. Could instead do myRound[8.121,1/100] and numericize afterward.
    $endgroup$
    – Daniel Lichtblau
    Mar 17 at 18:36













1












1








1





$begingroup$


As pointed out in this post, Mathematica has a special version of Round that




Round rounds numbers of the form x.5 toward the nearest even integer.




A comment by David G suggest that why not have differnt options Direction → "HalfDown","HalfUp","HalfEven","HalfOdd","Stochastic"



These days I need a version of Round to HalfUp. I write a quite ugly and slow function as below



myRound[x_, d_] := Module[,
c1 = (1./d)*10;
c2 = 1./d;
theDigit = Last@IntegerDigits@IntegerPart[x*c1];
If[theDigit >= 5,
Internal`StringToDouble@ToString@N[(IntegerPart[x*c2] + 1)/c2],
Internal`StringToDouble@ToString@N[(IntegerPart[x*c2])/c2]]]


speed test



In[267]:= 
myRound[#, 0.01] & /@ RandomReal[1., 1000000]; // AbsoluteTiming

Out[267]= 30.7072, Null

In[268]:=
Round[#, 0.01] & /@ RandomReal[1., 1000000]; // AbsoluteTiming

Out[268]= 0.285921, Null


So I am wondering if someone on this site already have developed an efficient toolkit for round matters?










share|improve this question











$endgroup$




As pointed out in this post, Mathematica has a special version of Round that




Round rounds numbers of the form x.5 toward the nearest even integer.




A comment by David G suggest that why not have differnt options Direction → "HalfDown","HalfUp","HalfEven","HalfOdd","Stochastic"



These days I need a version of Round to HalfUp. I write a quite ugly and slow function as below



myRound[x_, d_] := Module[,
c1 = (1./d)*10;
c2 = 1./d;
theDigit = Last@IntegerDigits@IntegerPart[x*c1];
If[theDigit >= 5,
Internal`StringToDouble@ToString@N[(IntegerPart[x*c2] + 1)/c2],
Internal`StringToDouble@ToString@N[(IntegerPart[x*c2])/c2]]]


speed test



In[267]:= 
myRound[#, 0.01] & /@ RandomReal[1., 1000000]; // AbsoluteTiming

Out[267]= 30.7072, Null

In[268]:=
Round[#, 0.01] & /@ RandomReal[1., 1000000]; // AbsoluteTiming

Out[268]= 0.285921, Null


So I am wondering if someone on this site already have developed an efficient toolkit for round matters?







machine-precision precision-and-accuracy round






share|improve this question















share|improve this question













share|improve this question




share|improve this question








edited Mar 17 at 11:59







matheorem

















asked Mar 17 at 11:54









matheoremmatheorem

6,65743178




6,65743178











  • $begingroup$
    Floor[x+0.5]?
    $endgroup$
    – Szabolcs
    Mar 17 at 11:58










  • $begingroup$
    @Szabolcs But Floor gives integer. Round can round at any digit
    $endgroup$
    – matheorem
    Mar 17 at 12:02






  • 2




    $begingroup$
    Are your aware of RoundingRule?
    $endgroup$
    – Silvia
    Mar 17 at 12:25






  • 1




    $begingroup$
    Could extend the method proposed by @Szabolcs: myRound[x_, d_] := d*Floor[x/d + 1/2]
    $endgroup$
    – Daniel Lichtblau
    Mar 17 at 13:58






  • 1




    $begingroup$
    That's a result of using decimal values e.g. .01 that do not have exact binary equivalents. Could instead do myRound[8.121,1/100] and numericize afterward.
    $endgroup$
    – Daniel Lichtblau
    Mar 17 at 18:36
















  • $begingroup$
    Floor[x+0.5]?
    $endgroup$
    – Szabolcs
    Mar 17 at 11:58










  • $begingroup$
    @Szabolcs But Floor gives integer. Round can round at any digit
    $endgroup$
    – matheorem
    Mar 17 at 12:02






  • 2




    $begingroup$
    Are your aware of RoundingRule?
    $endgroup$
    – Silvia
    Mar 17 at 12:25






  • 1




    $begingroup$
    Could extend the method proposed by @Szabolcs: myRound[x_, d_] := d*Floor[x/d + 1/2]
    $endgroup$
    – Daniel Lichtblau
    Mar 17 at 13:58






  • 1




    $begingroup$
    That's a result of using decimal values e.g. .01 that do not have exact binary equivalents. Could instead do myRound[8.121,1/100] and numericize afterward.
    $endgroup$
    – Daniel Lichtblau
    Mar 17 at 18:36















$begingroup$
Floor[x+0.5]?
$endgroup$
– Szabolcs
Mar 17 at 11:58




$begingroup$
Floor[x+0.5]?
$endgroup$
– Szabolcs
Mar 17 at 11:58












$begingroup$
@Szabolcs But Floor gives integer. Round can round at any digit
$endgroup$
– matheorem
Mar 17 at 12:02




$begingroup$
@Szabolcs But Floor gives integer. Round can round at any digit
$endgroup$
– matheorem
Mar 17 at 12:02




2




2




$begingroup$
Are your aware of RoundingRule?
$endgroup$
– Silvia
Mar 17 at 12:25




$begingroup$
Are your aware of RoundingRule?
$endgroup$
– Silvia
Mar 17 at 12:25




1




1




$begingroup$
Could extend the method proposed by @Szabolcs: myRound[x_, d_] := d*Floor[x/d + 1/2]
$endgroup$
– Daniel Lichtblau
Mar 17 at 13:58




$begingroup$
Could extend the method proposed by @Szabolcs: myRound[x_, d_] := d*Floor[x/d + 1/2]
$endgroup$
– Daniel Lichtblau
Mar 17 at 13:58




1




1




$begingroup$
That's a result of using decimal values e.g. .01 that do not have exact binary equivalents. Could instead do myRound[8.121,1/100] and numericize afterward.
$endgroup$
– Daniel Lichtblau
Mar 17 at 18:36




$begingroup$
That's a result of using decimal values e.g. .01 that do not have exact binary equivalents. Could instead do myRound[8.121,1/100] and numericize afterward.
$endgroup$
– Daniel Lichtblau
Mar 17 at 18:36










1 Answer
1






active

oldest

votes


















3












$begingroup$

I offer the following solution



r2[x_, a_] := x - Mod[x, a, -(a/2)]


We can verify that it has the desired result, using PiecewiseExpand



PiecewiseExpand[r2[x, a], -2 a < x < 2 a && a > 0]


Performance is only a little slower than the built-in Round



list = RandomReal[0, 1, 1000000];

AbsoluteTiming[Round[list, 0.1];]
(* 0.0079, Null *)

AbsoluteTiming[r2[list, 0.1];]
(* 0.009414, Null *)





share|improve this answer









$endgroup$












  • $begingroup$
    Wow, great solution. But there is a issue with hidden fractions as pointed out by mathematica.stackexchange.com/q/65298/4742 . But if we use InternalStringToDouble@ToString`, the performance will drop down.
    $endgroup$
    – matheorem
    Mar 17 at 13:22






  • 4




    $begingroup$
    @matheorem Technically, 1.265 in binary floating point corresponds to the fraction 5697053528623677/4503599627370496 which less than 1265/1000. The issue is due to rounding decimal to binary. Thus it is a problem of inputting the number you meant, not a problem with r2[].
    $endgroup$
    – Michael E2
    Mar 17 at 15:14






  • 2




    $begingroup$
    @matheorem The problem with imprecise calculation is that unwanted errors creep in, such as what you're complaining about. :) How about this?: r2[x_, a_] := x (1 + Sign[x] $MachineEpsilon) - Mod[x (1 + Sign[x] $MachineEpsilon), a, -(a/2)]
    $endgroup$
    – Michael E2
    Mar 17 at 15:40






  • 2




    $begingroup$
    @matheorem, I think you need to consider why you know the input is exactly 1.265 rather than a little more or a little less, and why the rounding is important to you. If you know the 3rd decimal place is exact, I suggest you multiply all your numbers by 1000, and work with integers.
    $endgroup$
    – mikado
    Mar 17 at 18:38







  • 1




    $begingroup$
    @matheorem That's what happens (automatically) when you use real (floating-point) numbers on all common CPUs.
    $endgroup$
    – Michael E2
    Mar 18 at 2:52










Your Answer





StackExchange.ifUsing("editor", function ()
return StackExchange.using("mathjaxEditing", function ()
StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix)
StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["$", "$"], ["\\(","\\)"]]);
);
);
, "mathjax-editing");

StackExchange.ready(function()
var channelOptions =
tags: "".split(" "),
id: "387"
;
initTagRenderer("".split(" "), "".split(" "), channelOptions);

StackExchange.using("externalEditor", function()
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled)
StackExchange.using("snippets", function()
createEditor();
);

else
createEditor();

);

function createEditor()
StackExchange.prepareEditor(
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: false,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: null,
bindNavPrevention: true,
postfix: "",
imageUploader:
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
,
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
);



);













draft saved

draft discarded


















StackExchange.ready(
function ()
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmathematica.stackexchange.com%2fquestions%2f193412%2fefficient-round-edition-with-different-rounding-direction%23new-answer', 'question_page');

);

Post as a guest















Required, but never shown

























1 Answer
1






active

oldest

votes








1 Answer
1






active

oldest

votes









active

oldest

votes






active

oldest

votes









3












$begingroup$

I offer the following solution



r2[x_, a_] := x - Mod[x, a, -(a/2)]


We can verify that it has the desired result, using PiecewiseExpand



PiecewiseExpand[r2[x, a], -2 a < x < 2 a && a > 0]


Performance is only a little slower than the built-in Round



list = RandomReal[0, 1, 1000000];

AbsoluteTiming[Round[list, 0.1];]
(* 0.0079, Null *)

AbsoluteTiming[r2[list, 0.1];]
(* 0.009414, Null *)





share|improve this answer









$endgroup$












  • $begingroup$
    Wow, great solution. But there is a issue with hidden fractions as pointed out by mathematica.stackexchange.com/q/65298/4742 . But if we use InternalStringToDouble@ToString`, the performance will drop down.
    $endgroup$
    – matheorem
    Mar 17 at 13:22






  • 4




    $begingroup$
    @matheorem Technically, 1.265 in binary floating point corresponds to the fraction 5697053528623677/4503599627370496 which less than 1265/1000. The issue is due to rounding decimal to binary. Thus it is a problem of inputting the number you meant, not a problem with r2[].
    $endgroup$
    – Michael E2
    Mar 17 at 15:14






  • 2




    $begingroup$
    @matheorem The problem with imprecise calculation is that unwanted errors creep in, such as what you're complaining about. :) How about this?: r2[x_, a_] := x (1 + Sign[x] $MachineEpsilon) - Mod[x (1 + Sign[x] $MachineEpsilon), a, -(a/2)]
    $endgroup$
    – Michael E2
    Mar 17 at 15:40






  • 2




    $begingroup$
    @matheorem, I think you need to consider why you know the input is exactly 1.265 rather than a little more or a little less, and why the rounding is important to you. If you know the 3rd decimal place is exact, I suggest you multiply all your numbers by 1000, and work with integers.
    $endgroup$
    – mikado
    Mar 17 at 18:38







  • 1




    $begingroup$
    @matheorem That's what happens (automatically) when you use real (floating-point) numbers on all common CPUs.
    $endgroup$
    – Michael E2
    Mar 18 at 2:52















3












$begingroup$

I offer the following solution



r2[x_, a_] := x - Mod[x, a, -(a/2)]


We can verify that it has the desired result, using PiecewiseExpand



PiecewiseExpand[r2[x, a], -2 a < x < 2 a && a > 0]


Performance is only a little slower than the built-in Round



list = RandomReal[0, 1, 1000000];

AbsoluteTiming[Round[list, 0.1];]
(* 0.0079, Null *)

AbsoluteTiming[r2[list, 0.1];]
(* 0.009414, Null *)





share|improve this answer









$endgroup$












  • $begingroup$
    Wow, great solution. But there is a issue with hidden fractions as pointed out by mathematica.stackexchange.com/q/65298/4742 . But if we use InternalStringToDouble@ToString`, the performance will drop down.
    $endgroup$
    – matheorem
    Mar 17 at 13:22






  • 4




    $begingroup$
    @matheorem Technically, 1.265 in binary floating point corresponds to the fraction 5697053528623677/4503599627370496 which less than 1265/1000. The issue is due to rounding decimal to binary. Thus it is a problem of inputting the number you meant, not a problem with r2[].
    $endgroup$
    – Michael E2
    Mar 17 at 15:14






  • 2




    $begingroup$
    @matheorem The problem with imprecise calculation is that unwanted errors creep in, such as what you're complaining about. :) How about this?: r2[x_, a_] := x (1 + Sign[x] $MachineEpsilon) - Mod[x (1 + Sign[x] $MachineEpsilon), a, -(a/2)]
    $endgroup$
    – Michael E2
    Mar 17 at 15:40






  • 2




    $begingroup$
    @matheorem, I think you need to consider why you know the input is exactly 1.265 rather than a little more or a little less, and why the rounding is important to you. If you know the 3rd decimal place is exact, I suggest you multiply all your numbers by 1000, and work with integers.
    $endgroup$
    – mikado
    Mar 17 at 18:38







  • 1




    $begingroup$
    @matheorem That's what happens (automatically) when you use real (floating-point) numbers on all common CPUs.
    $endgroup$
    – Michael E2
    Mar 18 at 2:52













3












3








3





$begingroup$

I offer the following solution



r2[x_, a_] := x - Mod[x, a, -(a/2)]


We can verify that it has the desired result, using PiecewiseExpand



PiecewiseExpand[r2[x, a], -2 a < x < 2 a && a > 0]


Performance is only a little slower than the built-in Round



list = RandomReal[0, 1, 1000000];

AbsoluteTiming[Round[list, 0.1];]
(* 0.0079, Null *)

AbsoluteTiming[r2[list, 0.1];]
(* 0.009414, Null *)





share|improve this answer









$endgroup$



I offer the following solution



r2[x_, a_] := x - Mod[x, a, -(a/2)]


We can verify that it has the desired result, using PiecewiseExpand



PiecewiseExpand[r2[x, a], -2 a < x < 2 a && a > 0]


Performance is only a little slower than the built-in Round



list = RandomReal[0, 1, 1000000];

AbsoluteTiming[Round[list, 0.1];]
(* 0.0079, Null *)

AbsoluteTiming[r2[list, 0.1];]
(* 0.009414, Null *)






share|improve this answer












share|improve this answer



share|improve this answer










answered Mar 17 at 12:33









mikadomikado

6,7471929




6,7471929











  • $begingroup$
    Wow, great solution. But there is a issue with hidden fractions as pointed out by mathematica.stackexchange.com/q/65298/4742 . But if we use InternalStringToDouble@ToString`, the performance will drop down.
    $endgroup$
    – matheorem
    Mar 17 at 13:22






  • 4




    $begingroup$
    @matheorem Technically, 1.265 in binary floating point corresponds to the fraction 5697053528623677/4503599627370496 which less than 1265/1000. The issue is due to rounding decimal to binary. Thus it is a problem of inputting the number you meant, not a problem with r2[].
    $endgroup$
    – Michael E2
    Mar 17 at 15:14






  • 2




    $begingroup$
    @matheorem The problem with imprecise calculation is that unwanted errors creep in, such as what you're complaining about. :) How about this?: r2[x_, a_] := x (1 + Sign[x] $MachineEpsilon) - Mod[x (1 + Sign[x] $MachineEpsilon), a, -(a/2)]
    $endgroup$
    – Michael E2
    Mar 17 at 15:40






  • 2




    $begingroup$
    @matheorem, I think you need to consider why you know the input is exactly 1.265 rather than a little more or a little less, and why the rounding is important to you. If you know the 3rd decimal place is exact, I suggest you multiply all your numbers by 1000, and work with integers.
    $endgroup$
    – mikado
    Mar 17 at 18:38







  • 1




    $begingroup$
    @matheorem That's what happens (automatically) when you use real (floating-point) numbers on all common CPUs.
    $endgroup$
    – Michael E2
    Mar 18 at 2:52
















  • $begingroup$
    Wow, great solution. But there is a issue with hidden fractions as pointed out by mathematica.stackexchange.com/q/65298/4742 . But if we use InternalStringToDouble@ToString`, the performance will drop down.
    $endgroup$
    – matheorem
    Mar 17 at 13:22






  • 4




    $begingroup$
    @matheorem Technically, 1.265 in binary floating point corresponds to the fraction 5697053528623677/4503599627370496 which less than 1265/1000. The issue is due to rounding decimal to binary. Thus it is a problem of inputting the number you meant, not a problem with r2[].
    $endgroup$
    – Michael E2
    Mar 17 at 15:14






  • 2




    $begingroup$
    @matheorem The problem with imprecise calculation is that unwanted errors creep in, such as what you're complaining about. :) How about this?: r2[x_, a_] := x (1 + Sign[x] $MachineEpsilon) - Mod[x (1 + Sign[x] $MachineEpsilon), a, -(a/2)]
    $endgroup$
    – Michael E2
    Mar 17 at 15:40






  • 2




    $begingroup$
    @matheorem, I think you need to consider why you know the input is exactly 1.265 rather than a little more or a little less, and why the rounding is important to you. If you know the 3rd decimal place is exact, I suggest you multiply all your numbers by 1000, and work with integers.
    $endgroup$
    – mikado
    Mar 17 at 18:38







  • 1




    $begingroup$
    @matheorem That's what happens (automatically) when you use real (floating-point) numbers on all common CPUs.
    $endgroup$
    – Michael E2
    Mar 18 at 2:52















$begingroup$
Wow, great solution. But there is a issue with hidden fractions as pointed out by mathematica.stackexchange.com/q/65298/4742 . But if we use InternalStringToDouble@ToString`, the performance will drop down.
$endgroup$
– matheorem
Mar 17 at 13:22




$begingroup$
Wow, great solution. But there is a issue with hidden fractions as pointed out by mathematica.stackexchange.com/q/65298/4742 . But if we use InternalStringToDouble@ToString`, the performance will drop down.
$endgroup$
– matheorem
Mar 17 at 13:22




4




4




$begingroup$
@matheorem Technically, 1.265 in binary floating point corresponds to the fraction 5697053528623677/4503599627370496 which less than 1265/1000. The issue is due to rounding decimal to binary. Thus it is a problem of inputting the number you meant, not a problem with r2[].
$endgroup$
– Michael E2
Mar 17 at 15:14




$begingroup$
@matheorem Technically, 1.265 in binary floating point corresponds to the fraction 5697053528623677/4503599627370496 which less than 1265/1000. The issue is due to rounding decimal to binary. Thus it is a problem of inputting the number you meant, not a problem with r2[].
$endgroup$
– Michael E2
Mar 17 at 15:14




2




2




$begingroup$
@matheorem The problem with imprecise calculation is that unwanted errors creep in, such as what you're complaining about. :) How about this?: r2[x_, a_] := x (1 + Sign[x] $MachineEpsilon) - Mod[x (1 + Sign[x] $MachineEpsilon), a, -(a/2)]
$endgroup$
– Michael E2
Mar 17 at 15:40




$begingroup$
@matheorem The problem with imprecise calculation is that unwanted errors creep in, such as what you're complaining about. :) How about this?: r2[x_, a_] := x (1 + Sign[x] $MachineEpsilon) - Mod[x (1 + Sign[x] $MachineEpsilon), a, -(a/2)]
$endgroup$
– Michael E2
Mar 17 at 15:40




2




2




$begingroup$
@matheorem, I think you need to consider why you know the input is exactly 1.265 rather than a little more or a little less, and why the rounding is important to you. If you know the 3rd decimal place is exact, I suggest you multiply all your numbers by 1000, and work with integers.
$endgroup$
– mikado
Mar 17 at 18:38





$begingroup$
@matheorem, I think you need to consider why you know the input is exactly 1.265 rather than a little more or a little less, and why the rounding is important to you. If you know the 3rd decimal place is exact, I suggest you multiply all your numbers by 1000, and work with integers.
$endgroup$
– mikado
Mar 17 at 18:38





1




1




$begingroup$
@matheorem That's what happens (automatically) when you use real (floating-point) numbers on all common CPUs.
$endgroup$
– Michael E2
Mar 18 at 2:52




$begingroup$
@matheorem That's what happens (automatically) when you use real (floating-point) numbers on all common CPUs.
$endgroup$
– Michael E2
Mar 18 at 2:52

















draft saved

draft discarded
















































Thanks for contributing an answer to Mathematica Stack Exchange!


  • Please be sure to answer the question. Provide details and share your research!

But avoid


  • Asking for help, clarification, or responding to other answers.

  • Making statements based on opinion; back them up with references or personal experience.

Use MathJax to format equations. MathJax reference.


To learn more, see our tips on writing great answers.




draft saved


draft discarded














StackExchange.ready(
function ()
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fmathematica.stackexchange.com%2fquestions%2f193412%2fefficient-round-edition-with-different-rounding-direction%23new-answer', 'question_page');

);

Post as a guest















Required, but never shown





















































Required, but never shown














Required, but never shown












Required, but never shown







Required, but never shown

































Required, but never shown














Required, but never shown












Required, but never shown







Required, but never shown







Popular posts from this blog

How should I support this large drywall patch? Planned maintenance scheduled April 23, 2019 at 00:00UTC (8:00pm US/Eastern) Announcing the arrival of Valued Associate #679: Cesar Manara Unicorn Meta Zoo #1: Why another podcast?How do I cover large gaps in drywall?How do I keep drywall around a patch from crumbling?Can I glue a second layer of drywall?How to patch long strip on drywall?Large drywall patch: how to avoid bulging seams?Drywall Mesh Patch vs. Bulge? To remove or not to remove?How to fix this drywall job?Prep drywall before backsplashWhat's the best way to fix this horrible drywall patch job?Drywall patching using 3M Patch Plus Primer

random experiment with two different functions on unit interval Announcing the arrival of Valued Associate #679: Cesar Manara Planned maintenance scheduled April 23, 2019 at 00:00UTC (8:00pm US/Eastern)Random variable and probability space notionsRandom Walk with EdgesFinding functions where the increase over a random interval is Poisson distributedNumber of days until dayCan an observed event in fact be of zero probability?Unit random processmodels of coins and uniform distributionHow to get the number of successes given $n$ trials , probability $P$ and a random variable $X$Absorbing Markov chain in a computer. Is “almost every” turned into always convergence in computer executions?Stopped random walk is not uniformly integrable

Lowndes Grove History Architecture References Navigation menu32°48′6″N 79°57′58″W / 32.80167°N 79.96611°W / 32.80167; -79.9661132°48′6″N 79°57′58″W / 32.80167°N 79.96611°W / 32.80167; -79.9661178002500"National Register Information System"Historic houses of South Carolina"Lowndes Grove""+32° 48' 6.00", −79° 57' 58.00""Lowndes Grove, Charleston County (260 St. Margaret St., Charleston)""Lowndes Grove"The Charleston ExpositionIt Happened in South Carolina"Lowndes Grove (House), Saint Margaret Street & Sixth Avenue, Charleston, Charleston County, SC(Photographs)"Plantations of the Carolina Low Countrye