help-gsl
[Top][All Lists]

## Re: [Help-gsl] Lognormal normal distribution within prescribed range lim

 From: Sam Mason Subject: Re: [Help-gsl] Lognormal normal distribution within prescribed range limits Date: Wed, 4 Jul 2012 15:21:06 +0100

```Hi,

Depending on what your parameters are; why not just use rejection
sampling?  I.e. something like:

double
ran_lognormal_range(const gsl_rng * r, double zeta, double sigma,
double min, double max)
{
while (1) {
double x = gsl_ran_lognormal(r, zeta, sigma);
if (x >= min && x < max)
return (x)
}
}

That this will obviously get pretty inefficient if you reject lots of
samples.  If you're after a probability density function as well it's
just a matter of using the cumulative density functions to calculate
how much of the distribution you're excluding.  This is also how much
things will slow down, i.e. if you're excluding half the domain then
you'll be excluding half of samples above.

Sam

On 4 July 2012 14:21, Ghani, Irfan <address@hidden> wrote:
> Hello,
> I am wondering, how can I get Lognormal distribution within a certain
> prescribed range limit. Following two functions gives lognormal variant and
> density distribution respectively in a range of [0, infinity].
>
> Function: double gsl_ran_lognormal (const gsl_rng * r, double zeta, double
> sigma);
> and
> Function: double gsl_ran_lognormal_pdf (double x, double zeta, double sigma)
>
> However, I could not figure out how to use these functions particularly the
> gsl_ran_lognormal() , to get a variant in a predefined range limit say [10,
> 200]. I will highly appreciate any sort of help and hint.
> Thanks.
>
> ________________________________________
> Sent: 30 June 2012 18:00
> Subject: Help-gsl Digest, Vol 104, Issue 17
>
> Send Help-gsl mailing list submissions to
>
> To subscribe or unsubscribe via the World Wide Web, visit
>         https://lists.gnu.org/mailman/listinfo/help-gsl
> or, via email, send a message with subject or body 'help' to
>
> You can reach the person managing the list at
>
> than "Re: Contents of Help-gsl digest..."
>
>
> Today's Topics:
>
>    1. Re: using histogram fuctions - not getting expected       result.
>       (Sam Mason)
>
>
> ----------------------------------------------------------------------
>
> Message: 1
> Date: Fri, 29 Jun 2012 17:13:30 +0100
> Subject: Re: [Help-gsl] using histogram fuctions - not getting
>         expected        result.
> Message-ID:
> Content-Type: text/plain; charset="UTF-8"
>
> On 29 June 2012 16:16, Calvin Morrison <address@hidden> wrote:
>> https://github.com/mutantturkey/FlyTracking/blob/master/fly-tools/derive-background/pixel.c
>
> You really don't need the GSL histogram routines for that; just something
> like:
>
> int
> findmax (uint8_t *p, int n)
> {
>   int mx = 0, v = p[0];
>   for (int i = 1; i < n; i++) {
>     if (p[i] > v) {
>       v = p[i];
>       mx = i;
>     }
>   }
>   return mx;
> }
>
>   uint8_t histr[256] = { 0 }, histg[256] = { 0 }, histb[256] = { 0 };
>
>   for (int i = 0; i < nImages; i++) {
>     histr[array[i][j][k][0]] += 1;
>     histg[array[i][j][k][1]] += 1;
>     histb[array[i][j][k][2]] += 1;
>   }
>
>   output[j][k][0] = findmax(histr, 256);
>   output[j][k][1] = findmax(histg, 256);
>   output[j][k][2] = findmax(histb, 256);
>
> I'd also recommend against storing the "array" as you are.  Traversing
> lots of pointers is particularly inefficient (probably important if
> you're in CS; chasing down four pointers is going to kill performance
> as this is in the inner loop).  It's much easier to allocate a big
> block of memory; i.e:
>
>   uint8_t * array = calloc(nImages * width * height * 3);
>
> and use the following to access an arbitrary pixel:
>
>   // return a pointer rgb pixel triplet
>   static inline uint8_t *getpixel(int image, int x, int y) { return
> &array[((image * width + x) * height + y) * 3]; }
>
> But for cases like where you're running along going over the same
> pixel for many images, you can do something like:
>
>   uint8_t *px = (j * height + k) * 3;
>   const size_t step = width * height * 3;
>   for (int i = 0; i < nImages; i++) {
>     histr[px[0]] += 1;
>     histg[px[1]] += 1;
>     histb[px[2]] += 1;
>     px += step;
>   }
>
> Also, just thought that if you've got more than about 500 images
> you're better off (i.e. your "working set" will be smaller) storing
> all the histograms (i.e. width*height*3 histograms) in memory and
> streaming through the images.  A
>
> Hope that helps!
>
>   Sam
>
>
>
>
> ------------------------------
>
> _______________________________________________
> Help-gsl mailing list
> https://lists.gnu.org/mailman/listinfo/help-gsl
>
>
> End of Help-gsl Digest, Vol 104, Issue 17
> *****************************************
>

```