Re: NMinimize eats all memory b/c of unnecessary symbolic work
- To: mathgroup at smc.vnet.net
- Subject: [mg120734] Re: NMinimize eats all memory b/c of unnecessary symbolic work
- From: DrMajorBob <btreat1 at austin.rr.com>
- Date: Mon, 8 Aug 2011 04:19:35 -0400 (EDT)
- Delivered-to: l-mathgroup@mail-archive0.wolfram.com
Eliminating Subscript should help with the memory issue:
n = 8*10^8;
k = 20;
a = N@Log@Prime@Range@k;
b = Table[Symbol["b" <> StringTake["0" <> ToString@i, -2]], {i, k}];
c = Times @@ (2 b + 1);
d = Sequence @@ Thread[b >= 0];
constraints = {c > n, d};
Minimize[{a.b, constraints}, b, Integers]
I didn't wait for that to complete, assuming it ever could.
It should help, as well, to find an upper bound for the variables,
changing "d" to
d = Sequence @@ Thread[bound > b >= 0];
I'll leave that to you.
Bobby
On Sun, 07 Aug 2011 05:15:37 -0500, Daniel Jensen <jensend at iname.com>
wrote:
> The following code is a fairly naive way to find the least number whose
> square has n divisors (the minimum should be its log and the x_i the
> powers in its prime factorization). If I look at the case n00 and use
> ten variables instead of twenty, this uses somewhere around 600MB of
> memory. With the value of n I'm actually trying to find the answer for,
> I need around 20 variables to be sure of not missing the actual
> solution, and it quickly uses up all available memory and then thrashes
> swap.
>
> n=8*10^6;
> a = Table[N[Log[Prime[i]]], {i, 20}];
> b = Table[Subscript[x, i], {i, 20}];
> cond = Fold[And, Product[2 Subscript[x, i] + 1, {i, 20}] > n,
> Table[Subscript[x, i] >= 0, {i, 20}]] && b \[Element] Integers;
> NMinimize[{a.b, cond}, b, MaxIterations -> 1000]
>
> It turns out that the problem isn't related to integer programming etc
> at all (removing the restriction to the integers doesn't help).
>
> My best guess is that the problem is that Mathematica is wasting all
> that memory expanding Product[2 Subscript[x, i] + 1, {i, 20}]. If I
> replace the product with just Product[Subscript[x, i],{i,20}] and change
> the constraints to be >= 1 rather than 0 I get results without a hassle
> and without the kernel using more than 50MB of memory. (Though that
> preserves the inequality constraint and doesn't change the task of
> minimizing the objective function, it does mess up the integrality
> requirement- I get even results, which correspond to half-integers in
> the actual problem.)
>
> Searching the Web, I found one person who had a somewhat similar
> problem; in their case, they had an objective function which was getting
> evaluated symbolically at a huge cost. They were able to remedy it by
> making the function only accept numeric input. I don't seem to be able
> to do that with the constraint.
>
> Any thoughts on how to fix this?
>
--
DrMajorBob at yahoo.com