Random Value Generation

RE: Random Value Generation

siddharthb0005 — Wed, 02 Feb 2022 18:06:15 GMT

joinarray(
a!forEach(items: enumerate(ri!range),
expression: char(65 + tointeger(rand()*(90-65)))),
""
)

RE: Random Value Generation

paulg0001 — Wed, 30 Sep 2020 15:48:00 GMT

Stefan! Bravo, Sir, Bravo!

This solution is incredible. I can't thank you enough. You knocked it out of the park!

RE: Random Value Generation

Stefan Helzle — Tue, 29 Sep 2020 05:39:52 GMT

This is how you do it. Define your range of available characters first, then select randomly. ceiling() is important to make sure the lowest number is 1.

a!localVariables(
  local!chars: touniformstring({enumerate(10), char(65 + enumerate(26))}),
  joinarray(
    {
      1,
      index(local!chars, ceiling(rand(16) * 36), "-")
    },
    ""
  )
)

RE: Random Value Generation

Siddharth — Tue, 29 Sep 2020 04:20:52 GMT

Does this help ?

a!localVariables(
  local!alpha: joinarray(
    {
      1,
      a!forEach(
        items: enumerate(
          16
        ),
        expression: {
          if(
            fixed(
              rand() * 2,
              0,
              true
            ),
            fixed(
              rand() * 10,
              0,
              true
            ),
            char(
              65 + tointeger(
                rand() * (
                  90 - 65
                )
              )
            )
          )
        }
      )
    }
  ),
  {
    local!alpha
  }
)

RE: Random Value Generation

paulg0001 — Mon, 28 Sep 2020 17:41:06 GMT

Hello again, Stefan!

I used this advice to create a random alpha-numeric 17 character string [ the first character is always the number 1, followed by 16 random alpha-numeric characters. Ex: 1UPJY54FL8YP3L760 ]:

a!localVariables(
  local!alpha: joinarray(
    {
      1,
      {
        if(
          fixed(rand()*2, 0, true),
          fixed(rand()*10, 0, true),
          char(65 + tointeger(rand() * (90-65)))
        )
      },
      {
        if(
          fixed(rand()*2, 0, true),
          fixed(rand()*10, 0, true),
          char(65 + tointeger(rand() * (90-65)))
        )
      },
      {
        if(
          fixed(rand()*2, 0, true),
          fixed(rand()*10, 0, true),
          char(65 + tointeger(rand() * (90-65)))
        )
      },
      {
        if(
          fixed(rand()*2, 0, true),
          fixed(rand()*10, 0, true),
          char(65 + tointeger(rand() * (90-65)))
        )
      },
      {
        if(
          fixed(rand()*2, 0, true),
          fixed(rand()*10, 0, true),
          char(65 + tointeger(rand() * (90-65)))
        )
      },
      {
        if(
          fixed(rand()*2, 0, true),
          fixed(rand()*10, 0, true),
          char(65 + tointeger(rand() * (90-65)))
        )
      },
      {
        if(
          fixed(rand()*2, 0, true),
          fixed(rand()*10, 0, true),
          char(65 + tointeger(rand() * (90-65)))
        )
      },
      {
        if(
          fixed(rand()*2, 0, true),
          fixed(rand()*10, 0, true),
          char(65 + tointeger(rand() * (90-65)))
        )
      },
      {
        if(
          fixed(rand()*2, 0, true),
          fixed(rand()*10, 0, true),
          char(65 + tointeger(rand() * (90-65)))
        )
      },
      {
        if(
          fixed(rand()*2, 0, true),
          fixed(rand()*10, 0, true),
          char(65 + tointeger(rand() * (90-65)))
        )
      },
      {
        if(
          fixed(rand()*2, 0, true),
          fixed(rand()*10, 0, true),
          char(65 + tointeger(rand() * (90-65)))
        )
      },
      {
        if(
          fixed(rand()*2, 0, true),
          fixed(rand()*10, 0, true),
          char(65 + tointeger(rand() * (90-65)))
        )
      },
      {
        if(
          fixed(rand()*2, 0, true),
          fixed(rand()*10, 0, true),
          char(65 + tointeger(rand() * (90-65)))
        )
      },
      {
        if(
          fixed(rand()*2, 0, true),
          fixed(rand()*10, 0, true),
          char(65 + tointeger(rand() * (90-65)))
        )
      },
      {
        if(
          fixed(rand()*2, 0, true),
          fixed(rand()*10, 0, true),
          char(65 + tointeger(rand() * (90-65)))
        )
      },
      {
        if(
          fixed(rand()*2, 0, true),
          fixed(rand()*10, 0, true),
          char(65 + tointeger(rand() * (90-65)))
        )
      }
    }
  ),
  {
    local!alpha
  }
)

I want to know if this can be refactored & simplified to repeat this chorus n-times?:

{
if(
fixed(rand()*2, 0, true),
fixed(rand()*10, 0, true),
char(65 + tointeger(rand() * (90-65)))
)
}

This is how I imagined it would work (but doesn't):

a!localVariables(
  local!alpha: reduce(
    if(
      fixed(rand()*2, 0, true),
      fixed(rand()*10, 0, true),
      char(65 + tointeger(rand() * (90-65)))
    ),
    {1},
    enum(16)
  ),
  local!alpha
)

RE: Random Value Generation

divyaa0001 — Mon, 15 Apr 2019 06:53:17 GMT

Thank you so much..It helped. I changed it to single line: index(ri!user,tointeger(fn!fixed(count(ri!user)*fn!rand()))+1,{})

RE: Random Value Generation

PhilB — Tue, 09 Apr 2019 19:09:24 GMT

In my experience they almost never want random, but load balanced... but the requirement definitely starts as "random"! :)

RE: Random Value Generation

Mike Schmitt — Tue, 09 Apr 2019 15:27:55 GMT

Maybe Divya is designing a game? But seriously also I've had my customer request that the system semi-randomly assign certain things to users in the past, so I see this as a real potential business use case.

RE: Random Value Generation

Robert Shankin — Tue, 09 Apr 2019 15:00:23 GMT

Why are you randomly selecting users from a group?

RE: Random Value Generation

davel001150 — Tue, 09 Apr 2019 14:37:22 GMT

Another option is tointeger(rand()*ri!range) . If you're going to be using rand() to pick a random item from a list, you should use tointeger(rand()*ri!range +1) to ensure that you don't include 0 in the results (because when you round 0.1242287 to 1's place you get 0) and you do include the top value of your range. If you don't include the +1 at the end you could find yourself running into errors due to Appian arrays starting at 1.

You may also, depending on the method you use to convert to integer, see Appian rounding up and already including the top number of your range. In that case, you may want to reduce your range by 1 so you don't get 11 in your results on occasion when you want 1 - 10. If it's vitally important that all random numbers be equally likely you may want to refine further how you convert response from rand() to an integer.

RE: Random Value Generation

Stewart Burchell — Mon, 08 Apr 2019 14:15:33 GMT

Yes. You'll need to do this steps:

get a list of all the Users you want to randomly select - let's call this local!users
derive the number of these - you can use fn!count() over the list from step 1
generate a random number using fn!rand()
multiply the count from step 2 by the value in step 3 - if the result is 0 - because rand() can return 0 - then you'll need to try again - let's call this local!randUserIndex - you'll need to coerce the result into an integer - use fn!integer(fn!fixed()) - this value represents an random index into your list of users
you can then simply return a user: local!users[local!randUserIndex]

Hope this helps

RE: Random Value Generation

divyaa0001 — Mon, 08 Apr 2019 13:29:29 GMT

Is there a way to use rand(), to randomly select user from a group?

RE: Random Value Generation

shakilahd — Thu, 08 Dec 2016 15:34:42 GMT

Yup.. Thank You!

RE: Random Value Generation

aloks0189 — Thu, 08 Dec 2016 15:20:21 GMT

@shakilahd You do something
=====================================
enumerate(10-6)+6
=====================================

Hope this will help you

RE: Random Value Generation

shakilahd — Thu, 08 Dec 2016 14:50:42 GMT

Hi.. is it possible to generate the series of number from specific range like 5 to 10 should returns 6,7,8,9.

RE: Random Value Generation

Stefan Helzle — Fri, 25 Nov 2016 10:39:57 GMT

You are welcome :-)

RE: Random Value Generation

aloks0189 — Fri, 25 Nov 2016 10:39:21 GMT

Thank You @stefanh791

RE: Random Value Generation

Stefan Helzle — Fri, 25 Nov 2016 10:33:14 GMT

Something like

fixed(rand()*ri!range, 0)

should do it.