commons-issues mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Venkatesha Murthy TS (JIRA)" <>
Subject [jira] [Updated] (MATH-1130) A new set of functions for copyof, remove and replace a given value on a slice of array
Date Mon, 23 Jun 2014 09:25:24 GMT


Venkatesha Murthy TS updated MATH-1130:

    Attachment: math-1130.patch

Added replace and remove methods into MathArrays. these have two flavours one with full array
and another flavour with (values, begin, length) just to be consistent with verifyValues and
copyOf where length is a parameter.  I am willing to change to make use of start and end indices
but felt that signature in verifyValues seemed more natural for me and hence continued the
same tradition even to these methods. (For eg: copyOf, verifyValues, System.arraycopy where
a start index/indices and a length is good to drive)

Added a canEqual method into MathUtils and have added testEquals and testCanEqual to indicate
canEqual runs faster. if you closely observe in testEquals i have reduced the for loop iteration
counts as otherwise if we made the same numbers as that of testCanEqual it would take very
long time.I have also tried with Precision.equalsIncludingNan but without much a success in
speed. I just added these high iteration counts to verify why canEqual may be better.

So either we could go with adding this new method
or alter MathUtils.equals or Precision.equasIncludingNaN methods.

Please let me know your thoughts

> A new set of functions for copyof, remove and replace a given value on a slice of array
> ---------------------------------------------------------------------------------------
>                 Key: MATH-1130
>                 URL:
>             Project: Commons Math
>          Issue Type: New Feature
>    Affects Versions: 3.4
>            Reporter: Venkatesha Murthy TS
>         Attachments: math-1130.patch
> These are utility functions mostly required as part of MathArrays.
> MathArrays:
> =============
> The requirement is as follows:
> a) double[] copyOf(double[] values, int begin, int length) ;
> Similar to most other functions that support slice defined  by  the array part from [begin,
begin+length) ;its a requirement to copy a slice which is not available (the closest is copyOf(array,
int len) which misses out the begin index)
> b) double[] removeAll(double[] values, int begin, int length, double removable);
> Need a function to remove a value from array slice defined by [begin,begin+length) and
return the filtered version.
> c) double[] replaceAll(double[] values, int begin, int length, double oldValue, double
> Need a function to replace inplace an oldValue substituted with newValue in the array
slice defined by [begin,begin+length) and return the original  complete array with just replaced
values only in the segment [begin,begin+length)
> MathUtils
> =========
> boolean canEqual(double d1, double d2) ;
> provide a canEqual function that is slightly better than exisitng MathUtils.equals. We
could also improve existing equals method however.
> So the change here is that the new enhanced canEqual can do a quick check on Nans and
as well as both +ve and -ve Infinities faster and then move to a detailed
method. This avoids the call for infinities and NaN with faster reference equal
check (i.e == ).

This message was sent by Atlassian JIRA

View raw message