December 2015 - Pharo-dev - lists.pharo.org

Re: [Pharo-dev] #sum:, #detectSum:, #sumNumbers:

by Thierry Goubier

2015-12-01 11:46 GMT+01:00 Sven Van Caekenberghe <sven(a)stfx.eu>: > The basic question for me is, what should > > #() sum > > return. Right now, it is an error, I would very much like that for this > common case the result would be 0. There is a lot of power (easy of use) in > a unary selector, we should not destroy that with semantics that force a > test before using it. > Yes, this is just that a 0 value is returned for an empty collection, and, if you're expecting a sum of Colors, then this is a bit strange. Returning an error on a sum for an empty collection is maybe an overall cleaner concept Which can be expressed as: I prefer this code: aCollectionOfColors isEmpty ifTrue: [ sumOfColors := aDefaultColor ] ifFalse: [ sumOfColors := aCollectionOfColors sum ] To this code: sumOfColors := aCollectionOfColors sum. sumOfColors = 0 ifTrue: [ sumOfColors := aDefaultColor ] > > If we agree on that, we could change the #sum to > > | sum sample | > self isEmpty ifTrue: [ ^ 0 ]. > sample := self anyOne. > sum := self inject: sample into: [ :accum :each | accum + each ]. > ^ sum - sample > Ok, now I really like this implementation. Elegant. Thierry > > And the same for #sum: > > As for #detectSum: that should be removed I think. > > > On 01 Dec 2015, at 10:33, Nicolai Hess <nicolaihess(a)gmail.com> wrote: > > > > > > > > 2015-12-01 10:26 GMT+01:00 Sven Van Caekenberghe <sven(a)stfx.eu>: > > > > > On 01 Dec 2015, at 10:18, Ben Coman <btc(a)openinworld.com> wrote: > > > > > > On Tue, Dec 1, 2015 at 4:45 PM, Sven Van Caekenberghe <sven(a)stfx.eu> > wrote: > > >> I am all for a cleanup, the current situation is confusing. > > >> The basic #sum should be fast AND work for empty collections with 0 > as starting element. > > > > > >> I know why the #anyOne is used, and that use case should be > preserved, but it is less common IMHO. > > > > > > I'm curious to be learn why? > > > > How many times have you summed a collection of things, where (1) you > could not start from the number 0 and (2) the operation was #+ ? Me, never, > and if I would need that, I would do an #inject:into: myself. Any counter > examples that occur a lot ? > > > > wokring with things like Color > > > > (Color wheel:10) sum "works" > > (Color wheel:10) newSum:#yourself " would not work" > > > > > > > > > cheers -ben > > > > > >> > > >>> On 01 Dec 2015, at 09:38, Thierry Goubier <thierry.goubier(a)gmail.com> > wrote: > > >>> > > >>> Hi Max, > > >>> > > >>> Interesting results... > > >>> > > >>> replacing the #yourself in newSum: cuts the runtime by a factor of > two. > > >>> using an [:x | x ] block cost 10% compared to a direct version of > sum. > > >>> > > >>> So the fastest sum is: > > >>> > > >>> sum > > >>> ^ self > > >>> inject: > > >>> (self ifEmpty: [ ^ 0 ] ifNotEmpty: [ self > anyOne ]) > > >>> into: [ :sum :each | sum + each ] > > >>> > > >>> And > > >>> > > >>> sum > > >>> ^ self sum: [:x | x ] > > >>> > > >>> is 10% slower. > > >>> > > >>> And > > >>> > > >>> sum > > >>> ^ self sum: #yourself > > >>> > > >>> is 100% slower (i.e. x2) > > >>> > > >>> It may be wise to avoid using #yourself for a block. > > >>> > > >>> Thierry > > >>> > > >>> > > >>> 2015-12-01 9:17 GMT+01:00 Max Leske <maxleske(a)gmail.com>: > > >>> Hi guys, > > >>> > > >>> Collection defines #sum:, #detectSum: and #sumNumbers:, all of which > accomplish the same (in principal) but with subtle differences: > > >>> > > >>> #sum: > > >>> - uses #inject:into: with #anyOne as the injected element and will > thus fail for empty collections > > >>> > > >>> #detectSum: > > >>> - uses ânextValue + sumâ instead of âsum + nextValueâ which makes it > a lot slower when dealing with large numbers (primitive fails and number > conversion is necessary) > > >>> > > >>> #sumNumbers: > > >>> - same as #sum but doesnât fail for empty collections. Only good for > numbers though. > > >>> > > >>> > > >>> Benchmarks: > > >>> > > >>> [ 100 timesRepeat: [ (1 to: 1000000) sum: #yourself ] ] timeToRun > 18062 > > >>> [ 100 timesRepeat: [ (1 to: 1000000) detectSum: #yourself ] ] > timeToRun 42391 > > >>> [ 100 timesRepeat: [ (1 to: 1000000) sumNumbers: #yourself ] ] > timeToRun 18096 > > >>> > > >>> > > >>> > > >>> Can we settle for a single implementation? Such as (modified from > #sumNumbers:): > > >>> > > >>> newSum: aBlock > > >>> ^ self > > >>> inject: (self > > >>> ifEmpty: [ 0 ] > > >>> ifNotEmpty: [ self anyOne ]) > > >>> into: [ :sum :each | sum + (aBlock value: each) ] > > >>> > > >>> This implementation combines the best of the three implementations I > think. Benchmark: > > >>> > > >>> [ 100 timesRepeat: [ (1 to: 1000000) newSum: #yourself ] ] timeToRun > 17955 > > >>> > > >>> > > >>> BTW, there is also the message #sum, which suffers from the same > problem as #sum: (the implementation is basically a copy). #sum could be > implemented as > > >>> > > >>> sum > > >>> ^ self sum: [ :x | x ] > > >>> > > >>> > > >>> As for the name for the new method, I suggest #sum:. > > >>> > > >>> Cheers, > > >>> Max > > >>> > > >> > > >> > > > > > > > > > > > >

Dec. 1, 2015

Re: [Pharo-dev] #sum:, #detectSum:, #sumNumbers:

by Sven Van Caekenberghe

The basic question for me is, what should #() sum return. Right now, it is an error, I would very much like that for this common case the result would be 0. There is a lot of power (easy of use) in a unary selector, we should not destroy that with semantics that force a test before using it. If we agree on that, we could change the #sum to | sum sample | self isEmpty ifTrue: [ ^ 0 ]. sample := self anyOne. sum := self inject: sample into: [ :accum :each | accum + each ]. ^ sum - sample And the same for #sum: As for #detectSum: that should be removed I think. > On 01 Dec 2015, at 10:33, Nicolai Hess <nicolaihess(a)gmail.com> wrote: > > > > 2015-12-01 10:26 GMT+01:00 Sven Van Caekenberghe <sven(a)stfx.eu>: > > > On 01 Dec 2015, at 10:18, Ben Coman <btc(a)openinworld.com> wrote: > > > > On Tue, Dec 1, 2015 at 4:45 PM, Sven Van Caekenberghe <sven(a)stfx.eu> wrote: > >> I am all for a cleanup, the current situation is confusing. > >> The basic #sum should be fast AND work for empty collections with 0 as starting element. > > > >> I know why the #anyOne is used, and that use case should be preserved, but it is less common IMHO. > > > > I'm curious to be learn why? > > How many times have you summed a collection of things, where (1) you could not start from the number 0 and (2) the operation was #+ ? Me, never, and if I would need that, I would do an #inject:into: myself. Any counter examples that occur a lot ? > > wokring with things like Color > > (Color wheel:10) sum "works" > (Color wheel:10) newSum:#yourself " would not work" > > > > > cheers -ben > > > >> > >>> On 01 Dec 2015, at 09:38, Thierry Goubier <thierry.goubier(a)gmail.com> wrote: > >>> > >>> Hi Max, > >>> > >>> Interesting results... > >>> > >>> replacing the #yourself in newSum: cuts the runtime by a factor of two. > >>> using an [:x | x ] block cost 10% compared to a direct version of sum. > >>> > >>> So the fastest sum is: > >>> > >>> sum > >>> ^ self > >>> inject: > >>> (self ifEmpty: [ ^ 0 ] ifNotEmpty: [ self anyOne ]) > >>> into: [ :sum :each | sum + each ] > >>> > >>> And > >>> > >>> sum > >>> ^ self sum: [:x | x ] > >>> > >>> is 10% slower. > >>> > >>> And > >>> > >>> sum > >>> ^ self sum: #yourself > >>> > >>> is 100% slower (i.e. x2) > >>> > >>> It may be wise to avoid using #yourself for a block. > >>> > >>> Thierry > >>> > >>> > >>> 2015-12-01 9:17 GMT+01:00 Max Leske <maxleske(a)gmail.com>: > >>> Hi guys, > >>> > >>> Collection defines #sum:, #detectSum: and #sumNumbers:, all of which accomplish the same (in principal) but with subtle differences: > >>> > >>> #sum: > >>> - uses #inject:into: with #anyOne as the injected element and will thus fail for empty collections > >>> > >>> #detectSum: > >>> - uses ânextValue + sumâ instead of âsum + nextValueâ which makes it a lot slower when dealing with large numbers (primitive fails and number conversion is necessary) > >>> > >>> #sumNumbers: > >>> - same as #sum but doesnât fail for empty collections. Only good for numbers though. > >>> > >>> > >>> Benchmarks: > >>> > >>> [ 100 timesRepeat: [ (1 to: 1000000) sum: #yourself ] ] timeToRun 18062 > >>> [ 100 timesRepeat: [ (1 to: 1000000) detectSum: #yourself ] ] timeToRun 42391 > >>> [ 100 timesRepeat: [ (1 to: 1000000) sumNumbers: #yourself ] ] timeToRun 18096 > >>> > >>> > >>> > >>> Can we settle for a single implementation? Such as (modified from #sumNumbers:): > >>> > >>> newSum: aBlock > >>> ^ self > >>> inject: (self > >>> ifEmpty: [ 0 ] > >>> ifNotEmpty: [ self anyOne ]) > >>> into: [ :sum :each | sum + (aBlock value: each) ] > >>> > >>> This implementation combines the best of the three implementations I think. Benchmark: > >>> > >>> [ 100 timesRepeat: [ (1 to: 1000000) newSum: #yourself ] ] timeToRun 17955 > >>> > >>> > >>> BTW, there is also the message #sum, which suffers from the same problem as #sum: (the implementation is basically a copy). #sum could be implemented as > >>> > >>> sum > >>> ^ self sum: [ :x | x ] > >>> > >>> > >>> As for the name for the new method, I suggest #sum:. > >>> > >>> Cheers, > >>> Max > >>> > >> > >> > > > > >

Dec. 1, 2015

Re: [Pharo-dev] #sum:, #detectSum:, #sumNumbers:

by Thierry Goubier

2015-12-01 10:29 GMT+01:00 Nicolai Hess <nicolaihess(a)gmail.com>: > > > 2015-12-01 10:26 GMT+01:00 Sven Van Caekenberghe <sven(a)stfx.eu>: > >> >> > On 01 Dec 2015, at 10:24, Thierry Goubier <thierry.goubier(a)gmail.com> >> wrote: >> > >> > Note that the sum with #anyOne is wrong. >> > >> > #(1 2 3 4 5) inject: #(1 2 3 4 5) anyOne into: [ :sum :each | sum + >> each ] >> > >> > returns 16 instead of 15. >> >> You have subtract the element you picked with #anyOne ! >> > > I think he means the suggested implementation for newSum is wrong, just > because of this reason. > > Exactly ;) Thierry

Dec. 1, 2015

[pharo-project/pharo-core]

by GitHub

Branch: refs/tags/50478 Home: https://github.com/pharo-project/pharo-core

Dec. 1, 2015

[pharo-project/pharo-core] f720c3: 50478

by GitHub

Branch: refs/heads/5.0 Home: https://github.com/pharo-project/pharo-core Commit: f720c316501315a530a14e49d6445cd395a25151 https://github.com/pharo-project/pharo-core/commit/f720c316501315a530a14e49… Author: Jenkins Build Server <board(a)pharo-project.org> Date: 2015-12-01 (Tue, 01 Dec 2015) Changed paths: M Morphic-Base.package/MenuItemMorph.class/instance/events/activateOwnerMenu_.st M Nautilus.package/AbstractNautilusUI.class/instance/build ui text/buildNewCodeSourceAreaRubric.st A Reflectivity-Tools.package/Breakpoint.class/class/all/browseAll.st M Rubric.package/RubScrolledTextMorph.class/instance/initialize-release/beForSmalltalkCode.st R ScriptLoader50.package/ScriptLoader.class/instance/pharo - scripts/script50477.st A ScriptLoader50.package/ScriptLoader.class/instance/pharo - scripts/script50478.st R ScriptLoader50.package/ScriptLoader.class/instance/pharo - updates/update50477.st A ScriptLoader50.package/ScriptLoader.class/instance/pharo - updates/update50478.st M ScriptLoader50.package/ScriptLoader.class/instance/public/commentForCurrentUpdate.st Log Message: ----------- 50478 17162 add Breakpoint class >> #browseAll https://pharo.fogbugz.com/f/cases/17162 17168 #beForSmalltalkCode should enable #withTextSegmentIcons https://pharo.fogbugz.com/f/cases/17168 17145 remove watchpoint package https://pharo.fogbugz.com/f/cases/17145 17158 submenu does not close on mouse leave / can not open another submenu https://pharo.fogbugz.com/f/cases/17158 http://files.pharo.org/image/50/50478.zip

Dec. 1, 2015

Re: [Pharo-dev] dual-monitor pharo

by Torsten Bergmann

Depends on how you want to use it. Two different OS Windows may be OK - but usually you want to display one world on several monitors similar to what for instance Window operating system itself is doing. So when you drag a Pharo window around you move it from one monitor to the other. For this you more work would be needed to check the monitors, provide this info from VM into Pharo itself, ... On Windows one could use EnumDisplayMonitors [1] that one could query (see [2]) or use during redrawing/a WM_PAINT event (see [3]). However this would require changing the VM - at least it would be the best place to put in a portable solution. Dont know for other platforms - but X11 should have similar support. Thx T. [1] https://msdn.microsoft.com/en-us/library/windows/desktop/dd162610(v=vs.85).… [2] https://www.realtimesoft.com/multimon/programming/ [3] http://www.codeproject.com/Articles/7831/Dual-Multiple-Monitor-Support-in-W… > Gesendet: Dienstag, 01. Dezember 2015 um 09:54 Uhr > Von: "Tudor Girba" <tudor(a)tudorgirba.com> > An: "Pharo Development List" <pharo-dev(a)lists.pharo.org> > Betreff: Re: [Pharo-dev] dual-monitor pharo > > Hi, > > Probably you need to have two different operating system windows. > > In this case, the work you are probably interested in is OSWindow. For example, when you now switch to a Bloc world, you will get a separate OS window. > > Cheers, > Doru > > > > On Dec 1, 2015, at 8:50 AM, Peter Uhnak <i.uhnak(a)gmail.com> wrote: > > > > Hi, > > > > has there been any effort done on running pharo on multiple monitors? > > > > Is it something that would require deep changes to VM? Can it be done > > image-side? > > > > Thanks, > > -- > > Peter > > > > -- > www.tudorgirba.com > > "Problem solving should be focused on describing > the problem in a way that makes the solution obvious." > > > > > >

Dec. 1, 2015

Re: [Pharo-dev] #sum:, #detectSum:, #sumNumbers:

by Nicolai Hess

2015-12-01 10:26 GMT+01:00 Sven Van Caekenberghe <sven(a)stfx.eu>: > > > On 01 Dec 2015, at 10:18, Ben Coman <btc(a)openinworld.com> wrote: > > > > On Tue, Dec 1, 2015 at 4:45 PM, Sven Van Caekenberghe <sven(a)stfx.eu> > wrote: > >> I am all for a cleanup, the current situation is confusing. > >> The basic #sum should be fast AND work for empty collections with 0 as > starting element. > > > >> I know why the #anyOne is used, and that use case should be preserved, > but it is less common IMHO. > > > > I'm curious to be learn why? > > How many times have you summed a collection of things, where (1) you could > not start from the number 0 and (2) the operation was #+ ? Me, never, and > if I would need that, I would do an #inject:into: myself. Any counter > examples that occur a lot ? > wokring with things like Color (Color wheel:10) sum "works" (Color wheel:10) newSum:#yourself " would not work" > > > cheers -ben > > > >> > >>> On 01 Dec 2015, at 09:38, Thierry Goubier <thierry.goubier(a)gmail.com> > wrote: > >>> > >>> Hi Max, > >>> > >>> Interesting results... > >>> > >>> replacing the #yourself in newSum: cuts the runtime by a factor of two. > >>> using an [:x | x ] block cost 10% compared to a direct version of sum. > >>> > >>> So the fastest sum is: > >>> > >>> sum > >>> ^ self > >>> inject: > >>> (self ifEmpty: [ ^ 0 ] ifNotEmpty: [ self anyOne > ]) > >>> into: [ :sum :each | sum + each ] > >>> > >>> And > >>> > >>> sum > >>> ^ self sum: [:x | x ] > >>> > >>> is 10% slower. > >>> > >>> And > >>> > >>> sum > >>> ^ self sum: #yourself > >>> > >>> is 100% slower (i.e. x2) > >>> > >>> It may be wise to avoid using #yourself for a block. > >>> > >>> Thierry > >>> > >>> > >>> 2015-12-01 9:17 GMT+01:00 Max Leske <maxleske(a)gmail.com>: > >>> Hi guys, > >>> > >>> Collection defines #sum:, #detectSum: and #sumNumbers:, all of which > accomplish the same (in principal) but with subtle differences: > >>> > >>> #sum: > >>> - uses #inject:into: with #anyOne as the injected element and will > thus fail for empty collections > >>> > >>> #detectSum: > >>> - uses ânextValue + sumâ instead of âsum + nextValueâ which makes it a > lot slower when dealing with large numbers (primitive fails and number > conversion is necessary) > >>> > >>> #sumNumbers: > >>> - same as #sum but doesnât fail for empty collections. Only good for > numbers though. > >>> > >>> > >>> Benchmarks: > >>> > >>> [ 100 timesRepeat: [ (1 to: 1000000) sum: #yourself ] ] timeToRun 18062 > >>> [ 100 timesRepeat: [ (1 to: 1000000) detectSum: #yourself ] ] > timeToRun 42391 > >>> [ 100 timesRepeat: [ (1 to: 1000000) sumNumbers: #yourself ] ] > timeToRun 18096 > >>> > >>> > >>> > >>> Can we settle for a single implementation? Such as (modified from > #sumNumbers:): > >>> > >>> newSum: aBlock > >>> ^ self > >>> inject: (self > >>> ifEmpty: [ 0 ] > >>> ifNotEmpty: [ self anyOne ]) > >>> into: [ :sum :each | sum + (aBlock value: each) ] > >>> > >>> This implementation combines the best of the three implementations I > think. Benchmark: > >>> > >>> [ 100 timesRepeat: [ (1 to: 1000000) newSum: #yourself ] ] timeToRun > 17955 > >>> > >>> > >>> BTW, there is also the message #sum, which suffers from the same > problem as #sum: (the implementation is basically a copy). #sum could be > implemented as > >>> > >>> sum > >>> ^ self sum: [ :x | x ] > >>> > >>> > >>> As for the name for the new method, I suggest #sum:. > >>> > >>> Cheers, > >>> Max > >>> > >> > >> > > > > >

Dec. 1, 2015

Re: [Pharo-dev] #sum:, #detectSum:, #sumNumbers:

by Nicolai Hess

2015-12-01 10:26 GMT+01:00 Sven Van Caekenberghe <sven(a)stfx.eu>: > > > On 01 Dec 2015, at 10:24, Thierry Goubier <thierry.goubier(a)gmail.com> > wrote: > > > > Note that the sum with #anyOne is wrong. > > > > #(1 2 3 4 5) inject: #(1 2 3 4 5) anyOne into: [ :sum :each | sum + each > ] > > > > returns 16 instead of 15. > > You have subtract the element you picked with #anyOne ! > I think he means the suggested implementation for newSum is wrong, just because of this reason. > > > Thierry > > > > 2015-12-01 10:18 GMT+01:00 Ben Coman <btc(a)openinworld.com>: > > On Tue, Dec 1, 2015 at 4:45 PM, Sven Van Caekenberghe <sven(a)stfx.eu> > wrote: > > > I am all for a cleanup, the current situation is confusing. > > > The basic #sum should be fast AND work for empty collections with 0 as > starting element. > > > > > I know why the #anyOne is used, and that use case should be preserved, > but it is less common IMHO. > > > > I'm curious to be learn why? > > cheers -ben > > > > > > > >> On 01 Dec 2015, at 09:38, Thierry Goubier <thierry.goubier(a)gmail.com> > wrote: > > >> > > >> Hi Max, > > >> > > >> Interesting results... > > >> > > >> replacing the #yourself in newSum: cuts the runtime by a factor of > two. > > >> using an [:x | x ] block cost 10% compared to a direct version of sum. > > >> > > >> So the fastest sum is: > > >> > > >> sum > > >> ^ self > > >> inject: > > >> (self ifEmpty: [ ^ 0 ] ifNotEmpty: [ self > anyOne ]) > > >> into: [ :sum :each | sum + each ] > > >> > > >> And > > >> > > >> sum > > >> ^ self sum: [:x | x ] > > >> > > >> is 10% slower. > > >> > > >> And > > >> > > >> sum > > >> ^ self sum: #yourself > > >> > > >> is 100% slower (i.e. x2) > > >> > > >> It may be wise to avoid using #yourself for a block. > > >> > > >> Thierry > > >> > > >> > > >> 2015-12-01 9:17 GMT+01:00 Max Leske <maxleske(a)gmail.com>: > > >> Hi guys, > > >> > > >> Collection defines #sum:, #detectSum: and #sumNumbers:, all of which > accomplish the same (in principal) but with subtle differences: > > >> > > >> #sum: > > >> - uses #inject:into: with #anyOne as the injected element and will > thus fail for empty collections > > >> > > >> #detectSum: > > >> - uses ânextValue + sumâ instead of âsum + nextValueâ which makes it > a lot slower when dealing with large numbers (primitive fails and number > conversion is necessary) > > >> > > >> #sumNumbers: > > >> - same as #sum but doesnât fail for empty collections. Only good for > numbers though. > > >> > > >> > > >> Benchmarks: > > >> > > >> [ 100 timesRepeat: [ (1 to: 1000000) sum: #yourself ] ] timeToRun > 18062 > > >> [ 100 timesRepeat: [ (1 to: 1000000) detectSum: #yourself ] ] > timeToRun 42391 > > >> [ 100 timesRepeat: [ (1 to: 1000000) sumNumbers: #yourself ] ] > timeToRun 18096 > > >> > > >> > > >> > > >> Can we settle for a single implementation? Such as (modified from > #sumNumbers:): > > >> > > >> newSum: aBlock > > >> ^ self > > >> inject: (self > > >> ifEmpty: [ 0 ] > > >> ifNotEmpty: [ self anyOne ]) > > >> into: [ :sum :each | sum + (aBlock value: each) ] > > >> > > >> This implementation combines the best of the three implementations I > think. Benchmark: > > >> > > >> [ 100 timesRepeat: [ (1 to: 1000000) newSum: #yourself ] ] timeToRun > 17955 > > >> > > >> > > >> BTW, there is also the message #sum, which suffers from the same > problem as #sum: (the implementation is basically a copy). #sum could be > implemented as > > >> > > >> sum > > >> ^ self sum: [ :x | x ] > > >> > > >> > > >> As for the name for the new method, I suggest #sum:. > > >> > > >> Cheers, > > >> Max > > >> > > > > > > > > > > > > >

Dec. 1, 2015

Re: [Pharo-dev] #sum:, #detectSum:, #sumNumbers:

by Sven Van Caekenberghe

> On 01 Dec 2015, at 10:24, Thierry Goubier <thierry.goubier(a)gmail.com> wrote: > > Note that the sum with #anyOne is wrong. > > #(1 2 3 4 5) inject: #(1 2 3 4 5) anyOne into: [ :sum :each | sum + each ] > > returns 16 instead of 15. You have subtract the element you picked with #anyOne ! > Thierry > > 2015-12-01 10:18 GMT+01:00 Ben Coman <btc(a)openinworld.com>: > On Tue, Dec 1, 2015 at 4:45 PM, Sven Van Caekenberghe <sven(a)stfx.eu> wrote: > > I am all for a cleanup, the current situation is confusing. > > The basic #sum should be fast AND work for empty collections with 0 as starting element. > > > I know why the #anyOne is used, and that use case should be preserved, but it is less common IMHO. > > I'm curious to be learn why? > cheers -ben > > > > >> On 01 Dec 2015, at 09:38, Thierry Goubier <thierry.goubier(a)gmail.com> wrote: > >> > >> Hi Max, > >> > >> Interesting results... > >> > >> replacing the #yourself in newSum: cuts the runtime by a factor of two. > >> using an [:x | x ] block cost 10% compared to a direct version of sum. > >> > >> So the fastest sum is: > >> > >> sum > >> ^ self > >> inject: > >> (self ifEmpty: [ ^ 0 ] ifNotEmpty: [ self anyOne ]) > >> into: [ :sum :each | sum + each ] > >> > >> And > >> > >> sum > >> ^ self sum: [:x | x ] > >> > >> is 10% slower. > >> > >> And > >> > >> sum > >> ^ self sum: #yourself > >> > >> is 100% slower (i.e. x2) > >> > >> It may be wise to avoid using #yourself for a block. > >> > >> Thierry > >> > >> > >> 2015-12-01 9:17 GMT+01:00 Max Leske <maxleske(a)gmail.com>: > >> Hi guys, > >> > >> Collection defines #sum:, #detectSum: and #sumNumbers:, all of which accomplish the same (in principal) but with subtle differences: > >> > >> #sum: > >> - uses #inject:into: with #anyOne as the injected element and will thus fail for empty collections > >> > >> #detectSum: > >> - uses ânextValue + sumâ instead of âsum + nextValueâ which makes it a lot slower when dealing with large numbers (primitive fails and number conversion is necessary) > >> > >> #sumNumbers: > >> - same as #sum but doesnât fail for empty collections. Only good for numbers though. > >> > >> > >> Benchmarks: > >> > >> [ 100 timesRepeat: [ (1 to: 1000000) sum: #yourself ] ] timeToRun 18062 > >> [ 100 timesRepeat: [ (1 to: 1000000) detectSum: #yourself ] ] timeToRun 42391 > >> [ 100 timesRepeat: [ (1 to: 1000000) sumNumbers: #yourself ] ] timeToRun 18096 > >> > >> > >> > >> Can we settle for a single implementation? Such as (modified from #sumNumbers:): > >> > >> newSum: aBlock > >> ^ self > >> inject: (self > >> ifEmpty: [ 0 ] > >> ifNotEmpty: [ self anyOne ]) > >> into: [ :sum :each | sum + (aBlock value: each) ] > >> > >> This implementation combines the best of the three implementations I think. Benchmark: > >> > >> [ 100 timesRepeat: [ (1 to: 1000000) newSum: #yourself ] ] timeToRun 17955 > >> > >> > >> BTW, there is also the message #sum, which suffers from the same problem as #sum: (the implementation is basically a copy). #sum could be implemented as > >> > >> sum > >> ^ self sum: [ :x | x ] > >> > >> > >> As for the name for the new method, I suggest #sum:. > >> > >> Cheers, > >> Max > >> > > > > > >

Dec. 1, 2015

Re: [Pharo-dev] #sum:, #detectSum:, #sumNumbers:

by Sven Van Caekenberghe

> On 01 Dec 2015, at 10:18, Ben Coman <btc(a)openinworld.com> wrote: > > On Tue, Dec 1, 2015 at 4:45 PM, Sven Van Caekenberghe <sven(a)stfx.eu> wrote: >> I am all for a cleanup, the current situation is confusing. >> The basic #sum should be fast AND work for empty collections with 0 as starting element. > >> I know why the #anyOne is used, and that use case should be preserved, but it is less common IMHO. > > I'm curious to be learn why? How many times have you summed a collection of things, where (1) you could not start from the number 0 and (2) the operation was #+ ? Me, never, and if I would need that, I would do an #inject:into: myself. Any counter examples that occur a lot ? > cheers -ben > >> >>> On 01 Dec 2015, at 09:38, Thierry Goubier <thierry.goubier(a)gmail.com> wrote: >>> >>> Hi Max, >>> >>> Interesting results... >>> >>> replacing the #yourself in newSum: cuts the runtime by a factor of two. >>> using an [:x | x ] block cost 10% compared to a direct version of sum. >>> >>> So the fastest sum is: >>> >>> sum >>> ^ self >>> inject: >>> (self ifEmpty: [ ^ 0 ] ifNotEmpty: [ self anyOne ]) >>> into: [ :sum :each | sum + each ] >>> >>> And >>> >>> sum >>> ^ self sum: [:x | x ] >>> >>> is 10% slower. >>> >>> And >>> >>> sum >>> ^ self sum: #yourself >>> >>> is 100% slower (i.e. x2) >>> >>> It may be wise to avoid using #yourself for a block. >>> >>> Thierry >>> >>> >>> 2015-12-01 9:17 GMT+01:00 Max Leske <maxleske(a)gmail.com>: >>> Hi guys, >>> >>> Collection defines #sum:, #detectSum: and #sumNumbers:, all of which accomplish the same (in principal) but with subtle differences: >>> >>> #sum: >>> - uses #inject:into: with #anyOne as the injected element and will thus fail for empty collections >>> >>> #detectSum: >>> - uses ânextValue + sumâ instead of âsum + nextValueâ which makes it a lot slower when dealing with large numbers (primitive fails and number conversion is necessary) >>> >>> #sumNumbers: >>> - same as #sum but doesnât fail for empty collections. Only good for numbers though. >>> >>> >>> Benchmarks: >>> >>> [ 100 timesRepeat: [ (1 to: 1000000) sum: #yourself ] ] timeToRun 18062 >>> [ 100 timesRepeat: [ (1 to: 1000000) detectSum: #yourself ] ] timeToRun 42391 >>> [ 100 timesRepeat: [ (1 to: 1000000) sumNumbers: #yourself ] ] timeToRun 18096 >>> >>> >>> >>> Can we settle for a single implementation? Such as (modified from #sumNumbers:): >>> >>> newSum: aBlock >>> ^ self >>> inject: (self >>> ifEmpty: [ 0 ] >>> ifNotEmpty: [ self anyOne ]) >>> into: [ :sum :each | sum + (aBlock value: each) ] >>> >>> This implementation combines the best of the three implementations I think. Benchmark: >>> >>> [ 100 timesRepeat: [ (1 to: 1000000) newSum: #yourself ] ] timeToRun 17955 >>> >>> >>> BTW, there is also the message #sum, which suffers from the same problem as #sum: (the implementation is basically a copy). #sum could be implemented as >>> >>> sum >>> ^ self sum: [ :x | x ] >>> >>> >>> As for the name for the new method, I suggest #sum:. >>> >>> Cheers, >>> Max >>> >> >> >

Dec. 1, 2015