Is there a Mathematica equivalent to MATLAB's logspace? [duplicate]

Question

Possible Duplicate:
How can I get exactly 5 logarithmic divisions of an interval?

I want to use Table to generate a list of items, but want the indices to be logarithmically spaced. Is there a simple way of doing this, or will I have to explicitly run linearly spaced indices through Exp to get my list?

Answer 1

Here's a somewhat simpler way:

 logspace[a_, b_, n_] := 10.0^Range[a, b, (b - a)/(n - 1)]

This gives a sequence starting at 10^a, ending at 10^b, with n points logarithmically spaced, as does Matlab's logspace( ) function.

Answer 2

I did a direct translation from Matlab file logspace.m with additional Mathematica minor touches.

Mathematica Function

logspace[d1_?(Element[#, Reals] &), 
         dd2_?(Element[#, Reals] &),
         n_?(IntegerQ[#] && # > 0 &)] := Module[{d2 = dd2, i},  

         If[d2 == Pi, d2 = Log[10, d2]];
         Flatten@{Table[10^(d1 + i*(d2 - d1)/(n - 1)), {i, 0, n - 2}], 10^d2}
     ]

logspace[d1_?(Element[#, Reals] &), d2_?(Element[#, Reals] &)]:= logspace[d1, d2, 50];

Tests

In[3]:= logspace[.1, 3, 3]    
Out[3]= {1.25893, 35.4813, 1000}

In[4]:= logspace[.1, 6, 3]    
Out[4]= {1.25893, 1122.02, 1000000}

In[5]:= logspace[.1, 6, 10]    
Out[5]= {1.25893, 5.69581, 25.7698, 116.591, 527.5, 2386.59, 10797.8, \
48852.7, 221027., 1000000}

In[6]:= logspace[.1, .4, 10]    
Out[6]= {1.25893, 1.35936, 1.4678, 1.58489, 1.71133, 1.84785, \
1.99526, 2.15443, 2.32631, 2.51189}

Matlab:

EDU>> logspace(.1,3,3)
       1.2589       35.481         1000

EDU>> logspace(.1,6,3)
       1.2589         1122        1e+06

EDU>> logspace(.1,6,10)'
       1.2589
       5.6958
        25.77
       116.59
        527.5
       2386.6
        10798
        48853
   2.2103e+05
        1e+06

EDU>> logspace(.1,.4,10)'
       1.2589
       1.3594
       1.4678
       1.5849
       1.7113
       1.8478
       1.9953
       2.1544
       2.3263
       2.5119

Answer 3

I don't belive there is a build in function for this, however you can easily do it using Range

 fSpace[min_, max_, steps_, f_: Log] :=  
      InverseFunction[f] /@ Range[f@min, f@max, (f@max - f@min)/(steps - 1)]

Inverse functions are being used so it'll give warnings in cases where you should be cautius, however it works for Log and other invertible functions.

 fSpace[1, 1000, 4]

{1, 10, 100, 1000}

{fSpace[1, 1000, 30, Sqrt[#] &], fSpace[1, 1000, 30]} // ListPlot

Update

I just discovered that you can in fact do even better out of the box by inverting the function only on the input range:

 fSpace[min_, max_, steps_, f_: Log] := 
  InverseFunction[ConditionalExpression[f[#], min < # < max] &] /@ 
  Range[f@min, f@max, (f@max - f@min)/(steps - 1)]

This still doesn't work arbitrarily, however it does help for instance selecting the positive square root in #^2&.