rand: Delete all doc tests

None of these actually compile any more!

1 files changed, 0 insertions, 168 deletions

diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index ca5a50f289a..e11a5818966 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -54,174 +54,6 @@
 //! -   On some systems (e.g. FreeBSD, OpenBSD and Mac OS X) there is no difference
 //!     between the two sources. (Also note that, on some systems e.g. FreeBSD, both `/dev/random`
 //!     and `/dev/urandom` may block once if the CSPRNG has not seeded yet.)
-//!
-//! # Examples
-//!
-//! ```rust
-//! # #![feature(rand)]
-//! use std::rand;
-//! use std::rand::Rng;
-//!
-//! let mut rng = rand::thread_rng();
-//! if rng.gen() { // random bool
-//!     println!("isize: {}, usize: {}", rng.gen::<isize>(), rng.gen::<usize>())
-//! }
-//! ```
-//!
-//! ```rust
-//! # #![feature(rand)]
-//! use std::rand;
-//!
-//! let tuple = rand::random::<(f64, char)>();
-//! println!("{:?}", tuple)
-//! ```
-//!
-//! ## Monte Carlo estimation of π
-//!
-//! For this example, imagine we have a square with sides of length 2 and a unit
-//! circle, both centered at the origin. Since the area of a unit circle is π,
-//! we have:
-//!
-//! ```text
-//!     (area of unit circle) / (area of square) = π / 4
-//! ```
-//!
-//! So if we sample many points randomly from the square, roughly π / 4 of them
-//! should be inside the circle.
-//!
-//! We can use the above fact to estimate the value of π: pick many points in the
-//! square at random, calculate the fraction that fall within the circle, and
-//! multiply this fraction by 4.
-//!
-//! ```
-//! # #![feature(rand)]
-//! use std::rand;
-//! use std::rand::distributions::{IndependentSample, Range};
-//!
-//! fn main() {
-//!    let between = Range::new(-1f64, 1.);
-//!    let mut rng = rand::thread_rng();
-//!
-//!    let total = 1_000_000;
-//!    let mut in_circle = 0;
-//!
-//!    for _ in 0..total {
-//!        let a = between.ind_sample(&mut rng);
-//!        let b = between.ind_sample(&mut rng);
-//!        if a*a + b*b <= 1. {
-//!            in_circle += 1;
-//!        }
-//!    }
-//!
-//!    // prints something close to 3.14159...
-//!    println!("{}", 4. * (in_circle as f64) / (total as f64));
-//! }
-//! ```
-//!
-//! ## Monty Hall Problem
-//!
-//! This is a simulation of the [Monty Hall Problem][]:
-//!
-//! > Suppose you're on a game show, and you're given the choice of three doors:
-//! > Behind one door is a car; behind the others, goats. You pick a door, say No. 1,
-//! > and the host, who knows what's behind the doors, opens another door, say No. 3,
-//! > which has a goat. He then says to you, "Do you want to pick door No. 2?"
-//! > Is it to your advantage to switch your choice?
-//!
-//! The rather unintuitive answer is that you will have a 2/3 chance of winning if
-//! you switch and a 1/3 chance of winning if you don't, so it's better to switch.
-//!
-//! This program will simulate the game show and with large enough simulation steps
-//! it will indeed confirm that it is better to switch.
-//!
-//! [Monty Hall Problem]: http://en.wikipedia.org/wiki/Monty_Hall_problem
-//!
-//! ```
-//! # #![feature(rand)]
-//! use std::rand;
-//! use std::rand::Rng;
-//! use std::rand::distributions::{IndependentSample, Range};
-//!
-//! struct SimulationResult {
-//!     win: bool,
-//!     switch: bool,
-//! }
-//!
-//! // Run a single simulation of the Monty Hall problem.
-//! fn simulate<R: Rng>(random_door: &Range<usize>, rng: &mut R) -> SimulationResult {
-//!     let car = random_door.ind_sample(rng);
-//!
-//!     // This is our initial choice
-//!     let mut choice = random_door.ind_sample(rng);
-//!
-//!     // The game host opens a door
-//!     let open = game_host_open(car, choice, rng);
-//!
-//!     // Shall we switch?
-//!     let switch = rng.gen();
-//!     if switch {
-//!         choice = switch_door(choice, open);
-//!     }
-//!
-//!     SimulationResult { win: choice == car, switch: switch }
-//! }
-//!
-//! // Returns the door the game host opens given our choice and knowledge of
-//! // where the car is. The game host will never open the door with the car.
-//! fn game_host_open<R: Rng>(car: usize, choice: usize, rng: &mut R) -> usize {
-//!     let choices = free_doors(&[car, choice]);
-//!     rand::sample(rng, choices.into_iter(), 1)[0]
-//! }
-//!
-//! // Returns the door we switch to, given our current choice and
-//! // the open door. There will only be one valid door.
-//! fn switch_door(choice: usize, open: usize) -> usize {
-//!     free_doors(&[choice, open])[0]
-//! }
-//!
-//! fn free_doors(blocked: &[usize]) -> Vec<usize> {
-//!     (0..3).filter(|x| !blocked.contains(x)).collect()
-//! }
-//!
-//! fn main() {
-//!     // The estimation will be more accurate with more simulations
-//!     let num_simulations = 10000;
-//!
-//!     let mut rng = rand::thread_rng();
-//!     let random_door = Range::new(0, 3);
-//!
-//!     let (mut switch_wins, mut switch_losses) = (0, 0);
-//!     let (mut keep_wins, mut keep_losses) = (0, 0);
-//!
-//!     println!("Running {} simulations...", num_simulations);
-//!     for _ in 0..num_simulations {
-//!         let result = simulate(&random_door, &mut rng);
-//!
-//!         match (result.win, result.switch) {
-//!             (true, true) => switch_wins += 1,
-//!             (true, false) => keep_wins += 1,
-//!             (false, true) => switch_losses += 1,
-//!             (false, false) => keep_losses += 1,
-//!         }
-//!     }
-//!
-//!     let total_switches = switch_wins + switch_losses;
-//!     let total_keeps = keep_wins + keep_losses;
-//!
-//!     println!("Switched door {} times with {} wins and {} losses",
-//!              total_switches, switch_wins, switch_losses);
-//!
-//!     println!("Kept our choice {} times with {} wins and {} losses",
-//!              total_keeps, keep_wins, keep_losses);
-//!
-//!     // With a large number of simulations, the values should converge to
-//!     // 0.667 and 0.333 respectively.
-//!     println!("Estimated chance to win if we switch: {}",
-//!              switch_wins as f32 / total_switches as f32);
-//!     println!("Estimated chance to win if we don't: {}",
-//!              keep_wins as f32 / total_keeps as f32);
-//! }
-//! ```
 
 #![unstable(feature = "rand")]