numerical

Does anybody know of an open source numerical C library that provides the logsumexp -function? The logsumexp(a) function computes the sum of exponentials log(e^{a_1}+...e^{a_n}) of the components of the array a, avoiding numerical overflow. Here's a very simple implementation from scratch (tested, at least minimally): double logsumexp(double nums[], size_t ct) { double max_exp = nums[0], sum = 0.0; size_t i; for (i = 1 ; i < ct ; i++) if (nums[i] > max_exp) max_exp = nums[i]; for (i = 0; i < ct ; i++) sum += exp(nums[i] - max_exp); return log(sum) + max_exp; } This does the trick of

As described in MSDN BigInteger is : An immutable type that represents an arbitrarily large integer whose value in theory has no upper or lower bounds. As I can see BigInteger is a ValueType , as much as I know, a ValueType must have a maximum size of 16 bytes . MSDN goes further saying : an OutOfMemoryException can be thrown for any operation that causes a BigInteger value to grow too large. and more : Although this process is transparent to the caller, it does incur a performance penalty. In some cases, especially when repeated operations are performed in a loop on very large BigInteger

This code works (C# 3) double d; if(d == (double)(int)d) ...; Is there a better way to do this? For extraneous reasons I want to avoid the double cast so; what nice ways exist other than this? (even if they aren't as good) Note: Several people pointed out the (important) point that == is often problematic regrading floating point. In this cases I expect values in the range of 0 to a few hundred and they are supposed to be integers (non ints are errors) so if those points "shouldn't" be an issue for me. d == Math.Floor(d) does the same thing in other words. NB: Hopefully you're aware that you

For intense number-crunching i'm considering using fixed point instead of floating point. Of course it'll matter how many bytes the fixed point type is in size, on what CPU it'll be running on, if i can use (for Intel) the MMX or SSE or whatever new things come up... I'm wondering if these days when floating point runs faster than ever, is it ever worth considering fixed point? Are there general rules of thumb where we can say it'll matter by more than a few percent? What is the overview from 35,000 feet of numerical performance? (BTW, i'm assuming a general CPU as found in most computers, not

Let's say I have three 32-bit floating point values, a , b , and c , such that (a + b) + c != a + (b + c) . Is there a summation algorithm, perhaps similar to Kahan summation , that guarantees that these values can be summed in any order and always arrive at the exact same (fairly accurate) total? I'm looking for the general case (i.e. not a solution that only deals with 3 numbers). Is arbitrary precision arithmetic the only way to go? I'm dealing with very large data sets, so I'd like to avoid the overhead of using arbitrary precision arithmetic if possible. Thanks! There's an interesting

I'm looking for a good easy to use Java based Quadratic Programming (QP) solver. Googling around I came across ojAlgo ( http://ojalgo.org ). However, I was wondering if there are any other/better alternatives. Have a look at Apache Commons Math . I haven't used ojalgo, and I really can't say I've used Commons Lang enough to be able to provide you with a lot of details, but it did do what I needed. Description from their website: Commons Math is a library of lightweight, self-contained mathematics and statistics components addressing the most common problems not available in the Java

Without any user interaction, how would a program identify what type of waveform is present in a recording from an ADC? For the sake of this question: triangle, square, sine, half-sine, or sawtooth waves of constant frequency. Level and frequency are arbitrary, and they will have noise, small amounts of distortion, and other imperfections. I'll propose a few (naive) ideas, too, and you can vote them up or down. You definitely want to start by taking an autocorrelation to find the fundamental. With that, take one period (approximately) of the waveform. Now take a DFT of that signal, and