search for: memoizing

My goal is simple: calcuate GC content of each sequence in a list of nucleotide sequences. I have figured out how to vectorize, but all my attempts at memoization failed. Can you show me how to properly memoize my function? There is a StackOverflow post on the subject of memoization, but it does not help me: http://stackoverflow.com/questions/7262485/options-for-caching-memoization-hashing-in-r

Hi, That''s a bit off topic but since I use Spork + Rspec... Well, my classes are reloaded between each test wave so Rails'' "memoize" method raises an error (which is expected, see code: http://rubydoc.info/docs/rails/3.0.0/ActiveSupport/Memoizable:memoize) Anyone resolved this issue with an elegant solution?

qemu feature detection takes about 95ms on my laptop. The overhead is almost all due to the time taken by the glibc link loader opening the 170+ libraries that qemu is linked to (×2 because we need to run qemu twice). Fixing that is seriously hard work. Therefore memoize the results of guestfs_int_test_qemu. This is keyed on the size and mtime of the qemu binary, so if the user changes the

This patch fixes an issue with protected methods becoming public if they are memoized. Looking for +1''s and/or a commit by core... https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/5695 Thanks. -- You received this message because you are subscribed to the Google Groups "Ruby on Rails: Core" group. To post to this group, send email to

Maybe this is because I''m missing something but it seems to me that asking users of a memoized method to know when the method needs to be reloaded is a bit backwards. To me it seems like whoever is messing with something that affects the results of the memoized function should be the one that after doing its work should call something like memoized_method(:reset). Thoughts? -- You

I was wondering what was the reasoning behind freezing the Memoizable return values? Thanks -- You received this message because you are subscribed to the Google Groups "Ruby on Rails: Talk" group. To post to this group, send email to rubyonrails-talk-/JYPxA39Uh5TLH3MbocFF+G/Ez6ZCGd0@public.gmane.org To unsubscribe from this group, send email to

I''m using the One-click 1.8.7rc2 Ruby Windows installer, everything has been working fine up till now, when i want to start getting into testing, i got this error, any reason why? C:/Ruby/bin/ruby -Ilib;test "C:/Ruby/lib/ruby/gems/1.8/gems/rake-0.8.3/ lib/rake/rake_test_loader.rb" "test/unit/word_test.rb" C:/Ruby/lib/ruby/1.8/erb.rb:469:in `scan'': You have a

I'd like to be able to change some default settings only in the case when checking a package with 'R CMD check'. More precisely, I'd like to execute a piece of R code before the Rd examples and/or test scripts are evaluated by 'R CMD check'. Is there a mechanism in 'R CMD check' that makes this possible? If not, is there a way to detect that you are running via

...gt; This may match something else in future, in case some other command of > qemu-img gets another option with "info" in it... > > TBH this is something we have already, and precisely in the qemu_data > struct, which is memoized. One downside is that using it would mean > memoizing the qemu help/schema in advance, even if the appliance is not > started; so code like `guestfish disk-format foo` will be slower. > OTOH, the upside is that there is no need to "reprobe" qemu-img for > something that we detect already from the QMP schema. So I had a look into th...

Hi, In my llvm code I want to create some function calls. The function prototype is as follows: int memoize ( char *function_name, int *int_params, unsigned num_ints, double *double_params, unsigned num_doubles) In order to create these calls I do the following for example: %88 = alloca [7 x i8] store volatile [7 x i8] c"ORACLE\00", [7 x i8]*

I hardly know anything about the format used in (non-compressed) serialization/RDS, but hoping someone with more knowledge could give me some feedback; Consider two R processes running in parallel on the same unknown file system. Both of them write and read to the same RDS file foo.rds (without compression) at random times using saveRDS(object, file="foo.rds", compress=FALSE) and

Instead of save every time there's a new element in the cache, batch the saving to disk every 100 changes, saving the unsaved remainder at the exit. While not a big optimization, this reduces a bit the disk usage during generator run. --- generator/utils.ml | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/generator/utils.ml b/generator/utils.ml index

https://bugs.launchpad.net/qemu/+bug/1740364 --- lib/guestfs-internal.h | 3 +++ lib/handle.c | 2 ++ lib/info.c | 39 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 44 insertions(+) diff --git a/lib/guestfs-internal.h b/lib/guestfs-internal.h index adeb9478a..c66c55e70 100644 --- a/lib/guestfs-internal.h +++ b/lib/guestfs-internal.h @@ -510,6 +510,9 @@ struct

I just filed bug 7872 about non-scalability of the LSR analysis algorithms. It may be related to bug 6727. The fundamental problem appears to be re-running SCEV analyses such as properlyDominates and SCEVComplexityCompare over and over again on large SCEV expressions. Memoizing results for SCEVComplexityCompare appears to help significantly but that is much harder to do with things like properlyDominates. Is anyone actively looking at LSR compile time issues? LLVM 2.7 is taking on the order of 30 minutes to optimize some very simple test cases and that's after doing...

...se some other command of > > > qemu-img gets another option with "info" in it... > > > > > > TBH this is something we have already, and precisely in the qemu_data > > > struct, which is memoized. One downside is that using it would mean > > > memoizing the qemu help/schema in advance, even if the appliance is not > > > started; so code like `guestfish disk-format foo` will be slower. > > > OTOH, the upside is that there is no need to "reprobe" qemu-img for > > > something that we detect already from the QMP sc...

Hi I have mailed about this previously, but back then it was not really confirmed, so I have let it be at that. Anyhow, problem is that for some reason 2.5/2.6 ext3 with HTREE support do not like what perl-5.8.0 does during installation. It *seems* like one of the temporary files created during manpage installation do not get unlinked properly, or gets into the hash (this possible?) and cause

Stack colouring should be able to reuse the same stack space, if the live ranges of the pointers don't overlap. But I don't think anyone has built a general solution for alloca'd space. On Mon, Nov 4, 2013 at 6:30 AM, Ali Javadi <aj14889 at yahoo.com> wrote: > Hi, > > In my llvm code I want to create some function calls. The function > prototype is as follows: >

...'info.*-U'"); This may match something else in future, in case some other command of qemu-img gets another option with "info" in it... TBH this is something we have already, and precisely in the qemu_data struct, which is memoized. One downside is that using it would mean memoizing the qemu help/schema in advance, even if the appliance is not started; so code like `guestfish disk-format foo` will be slower. OTOH, the upside is that there is no need to "reprobe" qemu-img for something that we detect already from the QMP schema. One possible idea can be to cache the...

...traversal-order-dependency that I’m seeing in IVUsers. Again, strikes me as incorrect because the behaviour is inconsistent. Actually, this sort of def-use chain traversal is why I think that it’s important to stop the DFT if encountering a use that’s a phi in the loop-header if we’re going to be memoizing the result of AddUsersImpl(). If we don’t stop the traversal in a header-phi, then we’d have a situation where we haven’t memoized the result of AddUsersImpl(%1) yet when calling AddUsersImpl(%1) for the second time — because we’re still trying to determine what AddUsersImpl(%1) will return in the...

...ing else in future, in case some other command of > > qemu-img gets another option with "info" in it... > > > > TBH this is something we have already, and precisely in the qemu_data > > struct, which is memoized. One downside is that using it would mean > > memoizing the qemu help/schema in advance, even if the appliance is not > > started; so code like `guestfish disk-format foo` will be slower. > > OTOH, the upside is that there is no need to "reprobe" qemu-img for > > something that we detect already from the QMP schema. > &gt...