See Also  edit

expr

srand

Mersenne Twister

Random

a cryptographically useful rand()

ycl math rand

Uses ycl math rng, which is cryptographically-strong, to produce a random number.

Cryptographically secure random numbers using /dev/urandom

another method for generating cryptographic random numbers

Secure-Programs-HOWTO

True Random Numbers

Bruce Hartweg mentions source of truly random data

Tcllib's simulation module

Commands to generate pseudo-random number generators

Examples  edit

Random Slash Maze

a very small and quirky visual example

Description  edit

expr { rand() }

expr {10+round(rand()*20)}

Random, comp.lang.tcl, 2008-08-08

rand()*20  has the range 0 to 19.9999999... 
round() applied to that expression has uniform 
probability of reaching each value in the range 
1 to 19, but only half that probability of 
reaching either 0 or 20.  To see why, consider 
the ranges that round() collapses on to each 
integer: 

  0.0 to 0.4  collapses to 0 
  0.5 to 1.4  collapses to 1 
  1.5 to 2.4  collapses to 2 
   .... 
  18.5 to 19.4  collapses to 19 
  19.5 to 19.99999999 collapses to 20 

Only half the real range for the extremes as for 
any of the other values! 

Try instead 
  expr { 10 + floor(rand() * 21.0) }

expr {int(rand()*20)}

x = (16807 * x) MOD 2147483647

/*
 * Generate the random number using the linear congruential generator
 * defined by the following recurrence:
 *                seed = ( IA * seed ) mod IM
 * where IA is 16807 and IM is (2^31) - 1. The recurrence maps a seed in
 * the range [1, IM - 1] to a new seed in that same range. The recurrence
 * maps IM to 0, and maps 0 back to 0, so those two values must not be
 * allowed as initial values of seed.
 *
 * In order to avoid potential problems with integer overflow, the
 * recurrence is implemented in terms of additional constants IQ and IR
 * such that
 *                IM = IA*IQ + IR
 * None of the operations in the implementation overflows a 32-bit signed
 * integer, and the C type long is guaranteed to be at least 32 bits wide.
 *
 * For more details on how this algorithm works, refer to the following
 * papers:
 *
 *        S.K. Park & K.W. Miller, "Random number generators: good ones are hard
 *        to find," Comm ACM 31(10):1192-1201, Oct 1988
 *
 *        W.H. Press & S.A. Teukolsky, "Portable random number generators,"
 *        Computers in Physics 6(5):522-524, Sep/Oct 1992.
 */

221072

proc lrandom L {
    lindex $L [expr {int(rand()*[llength $L])}]
} ;#RS

# generate random integer number in the range (0,max]
proc RandomInteger1 {max} {
    return [expr {int(rand()*$max) + 1}]
}

# generate random integer number in the range [0,max)
proc RandomInteger2 {max} {
    return [expr {int(rand()*$max)}]
}

# generate random integer number in the range [0,max]
proc RandomInteger3 {max} {
    return [expr {int(rand()*($max+1))}]
}

# generate random integer number in the range [min,max]
proc RandomInteger4 {min max} {
    return [expr {int(rand()*($max-$min+1)+$min)}]
}

proc random_int { upper_limit } {
    global myrand
    set myrand [expr int(rand() * $upper_limit + 1)]
    return $myrand
}

for {set i 0} {$i < 20} {incr i} {
    set result [random_int 12]
    puts -nonewline "\t $result"
}

proc random_int limit {
    expr {int(rand() * $limit +1)}
}

cvs -d:pserver:anonymous@cvs.tclsoap.sourceforge.net:/cvsroot/tclsoap co RandMT

proc lpick list {
    lindex $list [expr {int(rand()*[llength $list])}]
}

% lpick {red orange yellow green blue purple}
green ;# your result may be different ;-)

if {rand()<=0.25} {puts "25% chance"}

if {rand()<0.25} {puts "25% chance"}

#! /usr/local/bin/tclsh

proc r {limit} {
    return [expr {int(rand() * $limit)}]
}
 
proc lrepeat {value number} {
    set rlist [list]
    for {set i 0}  {$i < $number} {incr i} {
        lappend rlist $i $value
    }
    return $rlist
}
 
array set val [lrepeat 0 64]
for {set i 0} { $i < 1000} {incr i} {
    incr val([r 64])
}
puts "After filling"
set keys [lsort -integer [array names val]]
package require BLT
barchart .b -plotbackground black
pack .b
.b configure -title "expr rand's distribution" 
foreach key $keys {
    .b element create e$key -xdata $key -ydata $val($key)
}
 
# parray val

After filling
invalid command name "blt::barchart"
   while executing
"blt::barchart .b -plotbackground black"
   (file "/tmp/r.tcl" line 26)

% namespace children :: ;# is there a blt namespace at all?
% info commands b*

# assess.tcl Copyright (C) 2003 Pat Thoyts <patthoyts@users.sf.net>
#
# Attempt to assess the randomness of the rand() and randmt() function
# calls.
#
# 'assess' will print the standard deviation and chi-squared results for
# a given number of samples fitting into a number of buckets.
#
# $Id: 1549,v 1.46 2006-09-11 06:00:02 jcw Exp $

package require Tcl 8.4;                # we use lset
catch {package require RandMT};         # mersenne twister rand()

# -------------------------------------------------------------------------
# The random number generator functions. Each function here should return
# a single number between 0 and max each time it's called.

proc gen_rand {max} {
    return [expr {int(rand() * $max)}]
}

proc gen_randmt {max} {
    return [expr {int(randmt() * $max)}]
}

# -------------------------------------------------------------------------
# Fill a list with count values.

proc lrepeat {value count} {
    set r [list]
    for {set n 0} {$n < $count} {incr n} {
        lappend r $value
    }
    return $r
}

# -------------------------------------------------------------------------
# Generate count random numbers and assign into the list named by varname
# Use the random number generator function genProc.

proc fill {varname count genProc} {
    upvar $varname d
    set len [llength $d]
    for {set n 0} {$n < $count} {incr n} {
        set ndx [$genProc $len]
        set val [lindex $d $ndx]
        incr val
        lset d $ndx $val
    }
    return
}

# -------------------------------------------------------------------------
# Standard deviation for a list of values.

proc sd {l expected} {
    set sd 0
    set total 0
    set count [llength $l]
    for {set n 0} {$n < $count} {incr n} {
        set v [lindex $l $n]
        incr total $v
        set d [expr {double(abs($v - $expected)) / double($expected)}]
        set sd [expr {$sd + $d}]
    }
    set avg [expr {double($total) / double($count)}]
    return [list average $avg standard_deviation $sd]
}

# -------------------------------------------------------------------------
# Calculate the chi-squared for the result list.
# chi2 = sum [sqr(val - expected) / expected]

proc chi {l u} {
    set chi 0
    set count [llength $l]
    for {set n 0} {$n < $count} {incr n} {
        set v [lindex $l $n]
        set c [expr {pow($v - $u, 2) / double($u)}]
        #puts stderr "$n $v [expr {$v - $u}] [expr {pow($v - $u, 2)}] $c"
        set chi [expr {$chi + $c}]
    }
    return [list chi $chi]
}

# -------------------------------------------------------------------------
# The test proc.

proc assess {count {buckets 100} {procname gen_randmt}} {
    set bin [lrepeat 0 $buckets]
    fill bin $count ::$procname
    set n [expr {$count / $buckets}]
    puts "[sd $bin $n] [chi $bin $n]"
}

# -------------------------------------------------------------------------

if {$::tcl_interactive} {
    puts "try 'assess count ?buckets? ?generator?'"
} else {
    if {[llength $argv] < 1} {
        puts "usage: assess count ?buckets? ?generator?\n\
              eg: assess 100000 100 gen_rand\n\
                  assess 100000 100 gen_randmt"
        exit 1
    }
    catch {eval [list assess] $argv} msg
    puts $msg
}

# -------------------------------------------------------------------------
# Local variables:
#   mode: tcl
#   indent-tabs-mode: nil
# End:

# A silly "random number" generator -- this makes it obvious that the function has changed
proc myrand {} {return 0.50}

# Rename the mathfunc
proc tcl::mathfunc::rand {} {myrand}

% math::statistics::random-uniform 0 1 5
0.5 0.5 0.5 0.5 0.5

• Home
• Recent changes
• Help
• WhoAmI/Logout
• Create new page
• Random page
• Previous page
• Next page
• 
  
• Add comments
• Edit
• History
• Edit summary
• References