text:
William John Maxwell was a United States Navy officer who served as the 18th Naval Governor of Guam. He entered the United States Naval Academy in 1874, but was not commissioned as an ensign until 1883. He served aboard many ships before becoming one of the inaugural members of the General Board of the United States Navy. Afterward, he commanded both  and .

After becoming governor in 1914, Maxwell instituted a number of reforms, including establishing the Bank of Guam and the Guam Insular Patrol Force. He also reorganized the tax system and stressed the building and improvement of new roads. His plans to give Guamanians United States citizenship was rejected by then-Assistant Secretary of the Navy Franklin Delano Roosevelt. Guam became the center an international relations incident when the German  made port there asking for coal at a time when the United States remained neutral in World War I. Maxwell refused to break neutrality by providing fuel and supplies, forcing the ship to stay in port for the next two years. Maxwell attracted controversy during his term, particularly when he approved the first execution on the island since the US takeover. Eventually, a lower-ranking officer, William P. Cronan, placed Maxwell on the sick list, despite his protest, and removed him from power, taking the office himself. The Navy launched an inquiry into the appropriateness and motives of the dismissal, but nonetheless, Maxwell, declared perfectly healthy by mainland doctors, was reassigned to the Naval War College.

Naval career
Maxwell was appointed to the United States Naval Academy on June 8, 1874. On March 3, 1883, he was commissioned as an ensign junior grade, and an ensign on June 26, 1884.  He served aboard the training ship  from 1883 to 1885. On July 4, 1893, he was promoted to Lieutenant (junior grade). From July 1890 to March 1891, he served aboard the , before becoming the Assistant to the Inspector of the 5th Lighthouse District in July 1892.

In 1900, Maxwell began his assignment aboard . In 1905, as a Lieutenant Commander, he served as Chief Engineer on 's commissioning crew. In 1910 as a Commander, he served as one of the first members of the General Board of the United States Navy. On November 12, 1911, he left Hampton Roads, Virginia commanding , after being placed in command two days before. He continued in this position until 1912. In 1913, he commanded .

Governorship
Maxwell served as Naval Governor of Guam from March 28, 1914 to April 29, 1916. During his term, a typhoon hit in the summer of 1914, leaving a shortage of rice and corn crops. As governor, he established a number of government organizations, some still in existence. These organizations include the Guam Insular Patrol Force, the civilian predecessor to the Guam Police Department, as well as the Bank of Guam. He reorganized the taxation system by raising property assessments and stressed road building. The bank opened in January 1916 and helped many islanders obtain loans to open small businesses. He also served as the first chairman of the Guamanian chapter of the American Red Cross and organized its first fundraising drive. In 1914, Maxwell proposed granting United States citizenship to the people of Guam. However, Franklin Delano Roosevelt, then Assistant Secretary of the Navy, rejected the plan, claiming that making Guamanians citizens was not in the best interest of the country. He also asked that Guam be made an open port of trade to all ships, believing this would reduce the local's dependence on government assistance for food.

In December 1914, Maxwell found himself at the center of a diplomatic incident when the German Empire ship  stopped in Guam to resupply on coal. Maxwell, under orders to maintain American neutrality in the recently begun World War I, refused the ship supplies, instead forcing it to voluntarily inter itself at the island for the next two years.

Near the end of his term, Maxwell began coming into conflict with the islanders. He attracted some controversy when he outlawed public whistling, hoping to curtail mischievous local boys from whistling an incorrect cadence as sailors marched. He attracted larger anger when he ordered the first execution on the island since the United States had assumed control of it; despite numerous pleas to commute the sentence to life imprisonment, the man, Filipino Pablo Corpus, was executed for murder on February 4, 1916 by hanging. On April 29, 1916, William P. Cronan relieved Maxwell after involuntarily placing him on the sick list. However, upon transportation to the mainland United States, he was found to be perfectly healthy and reassigned to the Naval War College. The Navy launched an inquiry, led by Captain William R. Shoemaker, into the events surrounding Maxwell's dismissal and placement on the list by an officer of a lower rank. It was alleged that Cronan, then aide to the governor, disagreed with several of Maxwell's policies and used improper and unprofessional methods to oust him and take the position for himself.

Legacy
The Maxwell School, named after the governor, was built in Santa Rita, Guam in the early 1930s, but does not exist today.

References

Governors of Guam
United States Naval Academy alumni
Navy Midshipmen football players
American Red Cross personnel
United States Navy personnel of World War I
Naval War College faculty
Year of birth missing
Year of death missing


The 6th International Art in Early Childhood Conference was held at The Education University of Hong Kong, on 11-13 June 2015. More than 110 distinguished scholars, researchers, educators and practitioners in the field of art and early childhood education participated in the Conference.
There are six papers in the present volume of International Art in Early Childhood Research Journal. Four of the articles endeavour to explore the issue of developing early childhood educators' ability and confidence to make and teach art. Gai Lindsay challenges the mistaken assumptions that influence early childhood educators' visual art pedagogies and argues the need to support educators to evaluate critically the quality of visual art experiences offered to children. Jane Smyth and Diana Davis develop a mentoring programme which aims at building preschool teachers' confidence in art teaching. Allison Ohlsen studies the influence of visual arts experiences on student teachers' "attitudes, beliefs and perceptions of self-concept in the visual arts", (Ohlsen 2016), while Sarah Probine conducts a case study on the evolvement of early childhood teachers' visual arts pedagogies that value the role of visual art in children's construction of knowledge.
The other two articles in this volume engage readers to rethink the power of art for young children. Kathy Danko-McGhee looks into the connection between art experiences and literacy development in infants. Kathy documents the learning process of babies and their parents in an art gallery. Through critical discussion on a series of theories and examples of artworks, Felicity McArdle challenges early childhood teachers, art educators and academics to reflect on their own theories and practices in early childhood art education.
While enjoying the articles, spare time to reflect and develop your own ideas on art for young children to share with us in The 7th Art in Early Childhood Conference in 2017.


A security breach suffered by the Hotel booking software provider FastBooking has affected hundreds of hotels worldwide.
The Hotel booking software provider FastBooking is the last victim of a data breach, the incident exposed personal details and payment card data of guests from affected hotels.
FastBooking offers hotel booking platform to more than 4,000 hotels in 100 countries.
According to the experts, the number of impacted hotels worldwide could be greater than 1000, roughly 380 only in Japan. The company did not provide details about the number of affected users.
The company promptly notified via email the incident to each affected hotel providing details about the number of affected guests.
(computer activity traces) and we found out that some files containing data had leaked." reads a notice published by the company.
The attackers exploited a vulnerability in the web app to back into the FastBooking system.
The breach was discovered by company staff that noticed the presence of the malware on the server. The malware is a backdoor that allows the attacker to gain control over the server and steal the sensitive data.
The company notified the data breach via emails, hackers compromised the server on June 14 and installed a malware on the company server that was used to exfiltrate the precious data.
The hotel chain Prince Hotels & Resorts in Japan already notified the data breach to its customers. The hotel chain announced that the incident affected 124,963 guests who stayed at 82 of its hotels.
"This notice is to make you aware that Prince Hotels & Resorts reservations system in English, Simplified Chinese, Traditional Chinese, and Korean have been impacted by an unauthorized access to or acquisition of your personal information." reads the data breach notification.
June 14, 18, 8:43 PM UTC – hackers breached FastBooking's server.
June 19, 18, 3:40 PM UTC – The company discovers intrusion.
June 19, 18, 9:02 PM UTC – The company closes breach.
Experts believe this data breach could trigger a series of data breach notifications from all the affected hotels.


Even when traveling, the avid golfer is always looking to explore new courses and Austin, TX welcomes visitors, with open arms, to its many lush courses. Don't let the label of "The Live Music Capital of the World" fool you into thinking that is all there is in this southern town. The golf courses near Austin TX are designed and influenced by some of golf's great, such as Harvey Penick, Tom Kite, Ben Crenshaw and Arnold Palmer.
Whether it is a business trip that allows you to sneak in a round of golf, a special event, such as a wedding, or a planned golf vacation, the courses in the area are accommodating. Many offer club rental for those spur of the moment occasions and pro shops for gear and accessories. Once you have everything you need, it's time to hit the tee box, take in the views and enjoy a relaxing round of golf.
Austin and the surrounding area are home to some of the most prestigious private clubs, such as the Austin Country Club, which was designed by Harvey Penick. There are also several private golf resorts,including Wolfdancer Golf Club at Hyatt Lost Pines and Omni Barton Creek, which was designed by golfgreat, Tom Fazio. For those looking for a casual day on the course or something fun for the kid's, WillieNelson's Pedernales Golf Club Cut-n-Putt, a nine hole course, is the place to go. Who said the town of Austin couldn't mix music and golf together?
If you are traveling for business, or pleasure, and want to set up a golf tournament outing, Teravista Golf Club can accommodate. The course welcomes groups of any size and offers group discount rates. A PGA golf professional is involved in the planning and instruction of the event.
Teravista is an ideal place to host a golf destination wedding and reception. The Ranch House is offered for receptions and parties and has exceptional views of the rolling hills. A fully staffed event and catering crew are available to help with the planning of this special day. The event space, both inside and out, make for spectacular photo opportunities too. The Ranch House is available for other types of corporate or private events also.
The course spans 7,200 yards over the beautiful Hill Country and provides panoramic views of the land. Teravista is an 18 hole championship course which was created by the golf design group, Clifton-Ezell-Clifton with both the novice and expert golfer in mind. In fact, the National Golf Course Owners Association awarded this course the title, "Beginner Friendly Course."
Teravista Golf Club serves food or prepares take-out at its Caldwell Cafe, including breakfast and lunch. The course features a practice facility which includes a 22,000 square foot green, a chipping green and a range. The Pro Shop works well for those travelers taking in a spontaneous golf game, providing name brand gloves, balls, clothing and more.The quality courses available in and around Austin, TX won't disappoint visitors. Plan your next golf vacation, business outing or special event here for an unforgettable experience.


text:
#region License Information
/*
 * This file is part of SimSharp which is licensed under the MIT license.
 * See the LICENSE file in the project root for more information.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace SimSharp {
  /// <summary>
  /// Simulation hold the event queues, schedule and process events.
  /// </summary>
  /// <remarks>
  /// This class is not thread-safe against manipulation of the event queue. If you supply a termination
  /// event that is set outside the simulation thread, please use the <see cref="ThreadSafeSimulation"/> environment.
  ///
  /// For most purposes <see cref="Simulation"/> is however the better and faster choice.
  /// </remarks>
  public class Simulation {
    private const int InitialMaxEvents = 1024;

    /// <summary>
    /// Describes the number of seconds that a logical step of 1 in the *D-API takes.
    /// </summary>
    protected double DefaultTimeStepSeconds { get; private set; }

    /// <summary>
    /// Calculates the logical date of the simulation by the amount of default steps
    /// that have passed.
    /// </summary>
    public double NowD {
      get { return (Now - StartDate).TotalSeconds / DefaultTimeStepSeconds; }
    }

    private DateTime now;
    /// <summary>
    /// The current simulation time as a calendar date.
    /// </summary>
    public virtual DateTime Now { get => now; protected set => now = value; }

    /// <summary>
    /// The calendar date when the simulation started. This defaults to 1970-1-1 if
    /// no other date has been specified in the overloaded constructor.
    /// </summary>
    public DateTime StartDate { get; protected set; }

    /// <summary>
    /// The random number generator that is to be used in all events in
    /// order to produce reproducible results.
    /// </summary>
    protected IRandom Random { get; set; }

    protected EventQueue ScheduleQ;
    public Process ActiveProcess { get; set; }

    public TextWriter Logger { get; set; }
    public int ProcessedEvents { get; protected set; }

    public Simulation() : this(new DateTime(1970, 1, 1)) { }
    public Simulation(TimeSpan? defaultStep) : this(new DateTime(1970, 1, 1), defaultStep) { }
    public Simulation(int randomSeed, TimeSpan? defaultStep = null) : this(new DateTime(1970, 1, 1), randomSeed, defaultStep) { }
    public Simulation(DateTime initialDateTime, TimeSpan? defaultStep = null) : this(new PcgRandom(), initialDateTime, defaultStep) { }
    public Simulation(DateTime initialDateTime, int randomSeed, TimeSpan? defaultStep = null) : this(new PcgRandom(randomSeed), initialDateTime, defaultStep) { }
    public Simulation(IRandom random, DateTime initialDateTime, TimeSpan? defaultStep = null) {
      DefaultTimeStepSeconds = (defaultStep ?? TimeSpan.FromSeconds(1)).Duration().TotalSeconds;
      StartDate = initialDateTime;
      Now = initialDateTime;
      Random = random;
      ScheduleQ = new EventQueue(InitialMaxEvents);
      Logger = Console.Out;
    }

    public double ToDouble(TimeSpan span) {
      return span.TotalSeconds / DefaultTimeStepSeconds;
    }

    public TimeSpan ToTimeSpan(double span) {
      return TimeSpan.FromSeconds(DefaultTimeStepSeconds * span);
    }

    /// <summary>
    /// Creates a new process from an event generator. The process is automatically
    /// scheduled to be started at the current simulation time.
    /// </summary>
    /// <param name="generator">The generator function that represents the process.</param>
    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
    /// <returns>The scheduled process that was created.</returns>
    public Process Process(IEnumerable<Event> generator, int priority = 0) {
      return new Process(this, generator, priority);
    }

    /// <summary>
    /// Creates and returns a new timeout.
    /// </summary>
    /// <param name="delay">The time after which the timeout is fired.</param>
    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
    /// <returns>The scheduled timeout event that was created.</returns>
    public Timeout TimeoutD(double delay, int priority = 0) {
      return Timeout(TimeSpan.FromSeconds(DefaultTimeStepSeconds * delay), priority);
    }

    /// <summary>
    /// Creates and returns a new timeout.
    /// </summary>
    /// <param name="delay">The time after which the timeout is fired.</param>
    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
    /// <returns>The scheduled timeout event that was created.</returns>
    public Timeout Timeout(TimeSpan delay, int priority = 0) {
      return new Timeout(this, delay, priority: priority);
    }

    public virtual void Reset(int randomSeed) {
      ProcessedEvents = 0;
      Now = StartDate;
      Random = new PcgRandom(randomSeed);
      ScheduleQ = new EventQueue(InitialMaxEvents);
      normal.Reset();
    }

    public virtual void ScheduleD(double delay, Event @event) {
      Schedule(TimeSpan.FromSeconds(DefaultTimeStepSeconds * delay), @event);
    }

    /// <summary>
    /// Schedules an event to occur at the same simulation time as the call was made.
    /// </summary>
    /// <param name="event">The event that should be scheduled.</param>
    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
    public virtual void Schedule(Event @event, int priority = 0) {
      DoSchedule(Now, @event, priority);
    }

    /// <summary>
    /// Schedules an event to occur after a certain (positive) delay.
    /// </summary>
    /// <exception cref="ArgumentException">
    /// Thrown when <paramref name="delay"/> is negative.
    /// </exception>
    /// <param name="delay">The (positive) delay after which the event should be fired.</param>
    /// <param name="event">The event that should be scheduled.</param>
    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
    public virtual void Schedule(TimeSpan delay, Event @event, int priority = 0) {
      if (delay < TimeSpan.Zero)
        throw new ArgumentException("Negative delays are not allowed in Schedule(TimeSpan, Event).");
      var eventTime = Now + delay;
      DoSchedule(eventTime, @event, priority);
    }

    protected virtual EventQueueNode DoSchedule(DateTime date, Event @event, int priority = 0) {
      if (ScheduleQ.MaxSize == ScheduleQ.Count) {
        // the capacity has to be adjusted, there are more events in the queue than anticipated
        var oldSchedule = ScheduleQ;
        ScheduleQ = new EventQueue(ScheduleQ.MaxSize * 2);
        foreach (var e in oldSchedule) ScheduleQ.Enqueue(e.PrimaryPriority, e.Event, e.SecondaryPriority);
      }
      return ScheduleQ.Enqueue(date, @event, priority);
    }

    public virtual object RunD(double? until = null) {
      if (!until.HasValue) return Run();
      return Run(Now + TimeSpan.FromSeconds(DefaultTimeStepSeconds * until.Value));
    }

    public virtual object Run(TimeSpan span) {
      return Run(Now + span);
    }

    public virtual object Run(DateTime until) {
      if (until <= Now) throw new InvalidOperationException("Simulation end date must lie in the future.");
      var stopEvent = new Event(this);
      var node = DoSchedule(until, stopEvent);
      // stop event is always the first to execute at the given time
      node.InsertionIndex = -1;
      ScheduleQ.OnNodeUpdated(node);
      return Run(stopEvent);
    }

    protected CancellationTokenSource _stop = null;
    /// <summary>
    /// Run until a certain event is processed.
    /// </summary>
    /// <remarks>
    /// This simulation environment is not thread-safe, thus triggering this event outside the environment
    /// leads to potential race conditions. Please use the <see cref="ThreadSafeSimulation"/> environment in case you
    /// require this functionality. Note that the performance of <see cref="ThreadSafeSimulation"/> is lower due to locking.
    ///
    /// For real-time based termination, you can also call <see cref="StopAsync"/> which sets a flag indicating the simulation
    /// to stop before processing the next event.
    /// </remarks>
    /// <param name="stopEvent">The event that stops the simulation.</param>
    /// <returns></returns>
    public virtual object Run(Event stopEvent = null) {
      _stop = new CancellationTokenSource();
      if (stopEvent != null) {
        if (stopEvent.IsProcessed) {
          return stopEvent.Value;
        }
        stopEvent.AddCallback(StopSimulation);
      }
      OnRunStarted();
      try {
        var stop = ScheduleQ.Count == 0 || _stop.IsCancellationRequested;
        while (!stop) {
          Step();
          stop = ScheduleQ.Count == 0 || _stop.IsCancellationRequested;
        }
      } catch (StopSimulationException e) { OnRunFinished(); return e.Value; }
      OnRunFinished();
      if (stopEvent == null) return null;
      if (!_stop.IsCancellationRequested && !stopEvent.IsTriggered) throw new InvalidOperationException("No scheduled events left but \"until\" event was not triggered.");
      return stopEvent.Value;
    }

    public virtual void StopAsync() {
      _stop?.Cancel();
    }

    public event EventHandler RunStarted;
    protected void OnRunStarted() {
      RunStarted?.Invoke(this, EventArgs.Empty);
    }

    public event EventHandler RunFinished;
    protected void OnRunFinished() {
      RunFinished?.Invoke(this, EventArgs.Empty);
    }

    /// <summary>
    /// Performs a single step of the simulation, i.e. process a single event
    /// </summary>
    /// <remarks>
    /// This method is not thread-safe
    /// </remarks>
    public virtual void Step() {
      Event evt;
      var next = ScheduleQ.Dequeue();
      Now = next.PrimaryPriority;
      evt = next.Event;
      evt.Process();
      ProcessedEvents++;
    }

    /// <summary>
    /// Peeks at the time of the next event in terms of the defined step
    /// </summary>
    /// <remarks>
    /// This method is not thread-safe
    /// </remarks>
    public virtual double PeekD() {
      if (ScheduleQ.Count == 0) return double.MaxValue;
      return (Peek() - StartDate).TotalSeconds / DefaultTimeStepSeconds;
    }

    /// <summary>
    /// Peeks at the time of the next event
    /// </summary>
    /// <remarks>
    /// This method is not thread-safe
    /// </remarks>
    public virtual DateTime Peek() {
      return ScheduleQ.Count > 0 ? ScheduleQ.First.PrimaryPriority : DateTime.MaxValue;
    }

    protected virtual void StopSimulation(Event @event) {
      throw new StopSimulationException(@event.Value);
    }

    public virtual void Log(string message, params object[] args) {
      if (Logger != null)
        Logger.WriteLine(message, args);
    }

    #region Random number distributions
    public T Rand<T>(IDistribution<T> distribution) {
      return distribution.Sample(Random);
    }
    public IEnumerable<T> Rand<T>(IDistribution<T> distribution, int count) {
      return distribution.Sample(Random, count);
    }
    public bool TryRand<T>(IRejectionSampledDistribution<T> distribution, out T sample) {
      return distribution.TrySample(Random, out sample);
    }

    #region Obsolete code
    [Obsolete("Consider to use the respective distribution class")]
    public double RandUniform(IRandom random, double a, double b) {
      return Uniform.Sample(random, a, b);
    }
    [Obsolete("Consider to use the respective distribution class")]
    public double RandUniform(double a, double b) {
      return RandUniform(Random, a, b);
    }

    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandUniform(IRandom random, TimeSpan a, TimeSpan b) {
      return TimeSpan.FromSeconds(RandUniform(random, a.TotalSeconds, b.TotalSeconds));
    }
    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandUniform(TimeSpan a, TimeSpan b) {
      return RandUniform(Random, a, b);
    }
    [Obsolete("Consider to use the respective distribution class")]
    public double RandTriangular(IRandom random, double low, double high) {
      return Triangular.Sample(random, low, high);
    }
    [Obsolete("Consider to use the respective distribution class")]
    public double RandTriangular(double low, double high) {
      return RandTriangular(Random, low, high);
    }

    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandTriangular(IRandom random, TimeSpan low, TimeSpan high) {
      return TimeSpan.FromSeconds(RandTriangular(random, low.TotalSeconds, high.TotalSeconds));
    }
    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandTriangular(TimeSpan low, TimeSpan high) {
      return RandTriangular(Random, low, high);
    }

    [Obsolete("Consider to use the respective distribution class")]
    public double RandTriangular(IRandom random, double low, double high, double mode) {
      return Triangular.Sample(random, low, high, mode);
    }
    [Obsolete("Consider to use the respective distribution class")]
    public double RandTriangular(double low, double high, double mode) {
      return RandTriangular(Random, low, high, mode);
    }

    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandTriangular(IRandom random, TimeSpan low, TimeSpan high, TimeSpan mode) {
      return TimeSpan.FromSeconds(RandTriangular(random, low.TotalSeconds, high.TotalSeconds, mode.TotalSeconds));
    }
    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandTriangular(TimeSpan low, TimeSpan high, TimeSpan mode) {
      return RandTriangular(Random, low, high, mode);
    }

    /// <summary>
    /// Returns a number that is exponentially distributed given a certain mean.
    /// </summary>
    /// <remarks>
    /// Unlike in other APIs here the mean should be given and not the lambda parameter.
    /// </remarks>
    /// <param name="random">The random number generator to use.</param>
    /// <param name="mean">The mean(!) of the distribution is 1 / lambda.</param>
    /// <returns>A number that is exponentially distributed</returns>
    [Obsolete("Consider to use the respective distribution class")]
    public double RandExponential(IRandom random, double mean) {
      return Exponential.Sample(random, mean);
    }
    /// <summary>
    /// Returns a number that is exponentially distributed given a certain mean.
    /// </summary>
    /// <remarks>
    /// Unlike in other APIs here the mean should be given and not the lambda parameter.
    /// </remarks>
    /// <param name="mean">The mean(!) of the distribution is 1 / lambda.</param>
    /// <returns>A number that is exponentially distributed</returns>
    [Obsolete("Consider to use the respective distribution class")]
    public double RandExponential(double mean) {
      return RandExponential(Random, mean);
    }

    /// <summary>
    /// Returns a timespan that is exponentially distributed given a certain mean.
    /// </summary>
    /// <remarks>
    /// Unlike in other APIs here the mean should be given and not the lambda parameter.
    /// </remarks>
    /// <param name="random">The random number generator to use.</param>
    /// <param name="mean">The mean(!) of the distribution is 1 / lambda.</param>
    /// <returns>A number that is exponentially distributed</returns>
    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandExponential(IRandom random, TimeSpan mean) {
      return TimeSpan.FromSeconds(RandExponential(random, mean.TotalSeconds));
    }
    /// <summary>
    /// Returns a timespan that is exponentially distributed given a certain mean.
    /// </summary>
    /// <remarks>
    /// Unlike in other APIs here the mean should be given and not the lambda parameter.
    /// </remarks>
    /// <param name="mean">The mean(!) of the distribution is 1 / lambda.</param>
    /// <returns>A number that is exponentially distributed</returns>
    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandExponential(TimeSpan mean) {
      return RandExponential(Random, mean);
    }

    private Normal normal = new Normal(0, 1);

    /// <summary>
    /// Uses the Marsaglia polar method to generate a random variable
    /// from two uniform random distributed values.
    /// </summary>
    /// <remarks>
    /// Unlike <see cref="RandNormal(double, double)"/> this method does not
    /// make use of a spare random variable. It discards the spare and thus
    /// requires twice the number of calls to the underlying IRandom instance.
    /// </remarks>
    /// <param name="random">The random number generator to use.</param>
    /// <param name="mu">The mean of the normal distribution.</param>
    /// <param name="sigma">The standard deviation of the normal distribution.</param>
    /// <returns>A number that is normal distributed.</returns>
    [Obsolete("Consider to use the respective distribution class")]
    public virtual double RandNormal(IRandom random, double mu, double sigma) {
      return sigma * normal.Sample(random) + mu;
    }
    /// <summary>
    /// Uses the Marsaglia polar method to generate a random variable
    /// from two uniform random distributed values.
    /// </summary>
    /// <remarks>
    /// A spare random variable is generated from the second uniformly
    /// distributed value. Thus, the two calls to the uniform random number
    /// generator will be made only every second call.
    /// </remarks>
    /// <param name="mu">The mean of the normal distribution.</param>
    /// <param name="sigma">The standard deviation of the normal distribution.</param>
    /// <returns>A number that is normal distributed.</returns>
    [Obsolete("Consider to use the respective distribution class")]
    public virtual double RandNormal(double mu, double sigma) {
      return sigma * normal.Sample(Random) + mu;
    }

    /// <summary>
    /// Uses the Marsaglia polar method to generate a random variable
    /// from two uniform random distributed values.
    /// </summary>
    /// <remarks>
    /// A spare random variable is generated from the second uniformly
    /// distributed value. Thus, the two calls to the uniform random number
    /// generator will be made only every second call.
    /// </remarks>
    /// <param name="random">The random number generator to use.</param>
    /// <param name="mu">The mean of the normal distribution.</param>
    /// <param name="sigma">The standard deviation of the normal distribution.</param>
    /// <returns>A number that is normal distributed.</returns>
    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandNormal(IRandom random, TimeSpan mu, TimeSpan sigma) {
      return TimeSpan.FromSeconds(RandNormal(random, mu.TotalSeconds, sigma.TotalSeconds));
    }
    /// <summary>
    /// Uses the Marsaglia polar method to generate a random variable
    /// from two uniform random distributed values.
    /// </summary>
    /// <remarks>
    /// A spare random variable is generated from the second uniformly
    /// distributed value. Thus, the two calls to the uniform random number
    /// generator will be made only every second call.
    /// </remarks>
    /// <param name="mu">The mean of the normal distribution.</param>
    /// <param name="sigma">The standard deviation of the normal distribution.</param>
    /// <returns>A number that is normal distributed.</returns>
    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandNormal(TimeSpan mu, TimeSpan sigma) {
      return RandNormal(Random, mu, sigma);
    }

    [Obsolete("Consider to use the bounded distribution class")]
    public double RandNormalPositive(IRandom random, double mu, double sigma) {
      double val;
      do {
        val = RandNormal(random, mu, sigma);
      } while (val <= 0);
      return val;
    }
    [Obsolete("Consider to use the bounded distribution class")]
    public double RandNormalPositive(double mu, double sigma) {
      return RandNormalPositive(Random, mu, sigma);
    }

    [Obsolete("Consider to use the bounded distribution class")]
    public TimeSpan RandNormalPositive(IRandom random, TimeSpan mu, TimeSpan sigma) {
      return TimeSpan.FromSeconds(RandNormalPositive(random, mu.TotalSeconds, sigma.TotalSeconds));
    }
    [Obsolete("Consider to use the bounded distribution class")]
    public TimeSpan RandNormalPositive(TimeSpan mu, TimeSpan sigma) {
      return RandNormalPositive(Random, mu, sigma);
    }

    [Obsolete("Consider to use the bounded distribution class")]
    public double RandNormalNegative(IRandom random, double mu, double sigma) {
      double val;
      do {
        val = RandNormal(random, mu, sigma);
      } while (val >= 0);
      return val;
    }
    [Obsolete("Consider to use the bounded distribution class")]
    public double RandNormalNegative(double mu, double sigma) {
      return RandNormalNegative(Random, mu, sigma);
    }

    [Obsolete("Consider to use the bounded distribution class")]
    public TimeSpan RandNormalNegative(IRandom random, TimeSpan mu, TimeSpan sigma) {
      return TimeSpan.FromSeconds(RandNormalNegative(random, mu.TotalSeconds, sigma.TotalSeconds));
    }
    [Obsolete("Consider to use the bounded distribution class")]
    public TimeSpan RandNormalNegative(TimeSpan mu, TimeSpan sigma) {
      return RandNormalNegative(Random, mu, sigma);
    }

    /// <summary>
    /// Returns values from a log-normal distribution with the mean
    /// exp(mu + sigma^2 / 2)
    /// and the standard deviation
    /// sqrt([exp(sigma^2)-1] * exp(2 * mu + sigma^2))
    /// </summary>
    /// <param name="random">The random number generator to use.</param>
    /// <param name="mu">The mu parameter of the log-normal distribution (not the mean).</param>
    /// <param name="sigma">The sigma parameter of the log-normal distribution (not the standard deviation).</param>
    /// <returns>A log-normal distributed random value.</returns>
    [Obsolete("Consider to use the respective distribution class")]
    public double RandLogNormal(IRandom random, double mu, double sigma) {
      return Math.Exp(RandNormal(random, mu, sigma));
    }
    /// <summary>
    /// Returns values from a log-normal distribution with the mean
    /// exp(mu + sigma^2 / 2)
    /// and the standard deviation
    /// sqrt([exp(sigma^2)-1] * exp(2 * mu + sigma^2))
    /// </summary>
    /// <param name="mu">The mu parameter of the log-normal distribution (not the mean).</param>
    /// <param name="sigma">The sigma parameter of the log-normal distribution (not the standard deviation).</param>
    /// <returns>A log-normal distributed random value.</returns>
    [Obsolete("Consider to use the respective distribution class")]
    public double RandLogNormal(double mu, double sigma) {
      return RandLogNormal(Random, mu, sigma);
    }

    /// <summary>
    /// Returns values from a log-normal distribution with
    /// the mean <paramref name="mean"/> and standard deviation <paramref name="stdev"/>.
    /// </summary>
    /// <param name="random">The random number generator to use.</param>
    /// <param name="mean">The distribution mean.</param>
    /// <param name="stdev">The distribution standard deviation.</param>
    /// <returns>A log-normal distributed random value.</returns>
    [Obsolete("Consider to use the respective distribution class")]
    public double RandLogNormal2(IRandom random, double mean, double stdev) {
      if (stdev == 0) return mean;
      var sigma = Math.Sqrt(Math.Log(stdev * stdev / (mean * mean) + 1));
      var mu = Math.Log(mean) - 0.5 * sigma * sigma;
      return Math.Exp(RandNormal(random, mu, sigma));
    }
    /// <summary>
    /// Returns values from a log-normal distribution with
    /// the mean <paramref name="mean"/> and standard deviation <paramref name="stdev"/>.
    /// </summary>
    /// <param name="mean">The distribution mean.</param>
    /// <param name="stdev">The distribution standard deviation.</param>
    /// <returns>A log-normal distributed random value.</returns>
    [Obsolete("Consider to use the respective distribution class")]
    public double RandLogNormal2(double mean, double stdev) {
      return RandLogNormal2(Random, mean, stdev);
    }

    /// <summary>
    /// Returns a timespan value from a log-normal distribution with the mean
    /// exp(mu + sigma^2 / 2)
    /// and the standard deviation
    /// sqrt([exp(sigma^2)-1] * exp(2 * mu + sigma^2))
    /// </summary>
    /// <param name="random">The random number generator to use.</param>
    /// <param name="mu">The mu parameter of the log-normal distribution (not the mean).</param>
    /// <param name="sigma">The sigma parameter of the log-normal distribution (not the standard deviation).</param>
    /// <returns>A log-normal distributed random timespan.</returns>
    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandLogNormal(IRandom random, TimeSpan mu, TimeSpan sigma) {
      return TimeSpan.FromSeconds(RandLogNormal(random, mu.TotalSeconds, sigma.TotalSeconds));
    }
    /// <summary>
    /// Returns a timespan value from a log-normal distribution with the mean
    /// exp(mu + sigma^2 / 2)
    /// and the standard deviation
    /// sqrt([exp(sigma^2)-1] * exp(2 * mu + sigma^2))
    /// </summary>
    /// <param name="mu">The mu parameter of the log-normal distribution (not the mean).</param>
    /// <param name="sigma">The sigma parameter of the log-normal distribution (not the standard deviation).</param>
    /// <returns>A log-normal distributed random timespan.</returns>
    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandLogNormal(TimeSpan mu, TimeSpan sigma) {
      return RandLogNormal(Random, mu, sigma);
    }

    /// <summary>
    /// Returns a timespan value from a log-normal distribution with
    /// the mean <paramref name="mean"/> and standard deviation <paramref name="stdev"/>.
    /// </summary>
    /// <param name="random">The random number generator to use.</param>
    /// <param name="mean">The distribution mean.</param>
    /// <param name="stdev">The distribution standard deviation.</param>
    /// <returns>A log-normal distributed random timespan.</returns>
    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandLogNormal2(IRandom random, TimeSpan mean, TimeSpan stdev) {
      return TimeSpan.FromSeconds(RandLogNormal2(random, mean.TotalSeconds, stdev.TotalSeconds));
    }
    /// <summary>
    /// Returns a timespan value from a log-normal distribution with
    /// the mean <paramref name="mean"/> and standard deviation <paramref name="stdev"/>.
    /// </summary>
    /// <param name="mean">The distribution mean.</param>
    /// <param name="stdev">The distribution standard deviation.</param>
    /// <returns>A log-normal distributed random timespan.</returns>
    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandLogNormal2(TimeSpan mean, TimeSpan stdev) {
      return RandLogNormal2(Random, mean, stdev);
    }

    [Obsolete("Consider to use the respective distribution class")]
    public double RandCauchy(IRandom random, double x0, double gamma) {
      return Cauchy.Sample(random, x0, gamma);
    }
    [Obsolete("Consider to use the respective distribution class")]
    public double RandCauchy(double x0, double gamma) {
      return RandCauchy(Random, x0, gamma);
    }

    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandCauchy(IRandom random, TimeSpan x0, TimeSpan gamma) {
      return TimeSpan.FromSeconds(RandCauchy(random, x0.TotalSeconds, gamma.TotalSeconds));
    }
    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandCauchy(TimeSpan x0, TimeSpan gamma) {
      return RandCauchy(Random, x0, gamma);
    }

    [Obsolete("Consider to use the respective distribution class")]
    public double RandWeibull(IRandom random, double alpha, double beta) {
      return Weibull.Sample(random, alpha, beta);
    }
    [Obsolete("Consider to use the respective distribution class")]
    public double RandWeibull(double alpha, double beta) {
      return RandWeibull(Random, alpha, beta);
    }

    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandWeibull(IRandom random, TimeSpan alpha, TimeSpan beta) {
      return TimeSpan.FromSeconds(RandWeibull(random, alpha.TotalSeconds, beta.TotalSeconds));
    }
    [Obsolete("Consider to use the respective distribution class")]
    public TimeSpan RandWeibull(TimeSpan alpha, TimeSpan beta) {
      return RandWeibull(Random, alpha, beta);
    }

    /// <summary>
    /// This method chooses a single element from <paramref name="source"/> with equal probability.
    /// </summary>
    /// <param name="random">The random number generator to use.</param>
    /// <param name="source">The elements to choose from.</param>
    /// <typeparam name="T">The type of the elements to be chosen.</typeparam>
    /// <returns>The chosen element.</returns>
    [Obsolete("Consider to use the EmpiricalUniform distribution class")]
    public T RandChoice<T>(IRandom random, IList<T> source) {
      var idx = random.Next(source.Count);
      return source[idx];
    }
    /// <summary>
    /// Calls <see cref="RandChoice{T}(IRandom, IList{T})"/> with the default RNG instance <see cref="Random"/>.
    /// </summary>
    /// <param name="source">The elements to choose from.</param>
    /// <typeparam name="T">The type of the elements to be chosen.</typeparam>
    /// <returns>The chosen element.</returns>
    [Obsolete("Consider to use the EmpiricalUniform distribution class")]
    public T RandChoice<T>(IList<T> source) {
      return RandChoice(Random, source);
    }

    /// <summary>
    /// This method chooses <paramref name="count"/> elements from <paramref name="source"/> with repetition.
    /// </summary>
    /// <remarks>
    /// Runtime complexity for selecting M out of a list of N elements is O(M).
    /// Order is not preserved, the items are returned in arbitrary order.
    ///
    /// Parameter <paramref name="count"/> can be 0 in which case the enumerable will be empty.
    /// </remarks>
    /// <exception cref="ArgumentException">
    /// Thrown when <paramref name="count"/> is negative.
    /// </exception>
    /// <param name="random">The random number generator to use.</param>
    /// <param name="source">The elements to choose from.</param>
    /// <param name="count">The number of elements to choose.</param>
    /// <typeparam name="T">The type of the elements to be chosen.</typeparam>
    /// <returns>An enumeration of the elements.</returns>
    [Obsolete("Consider to use the EmpiricalUniform distribution class")]
    public IEnumerable<T> RandChoice<T>(IRandom random, IList<T> source, int count) {
      return new EmpiricalUniform<T>(source).Sample(random, count);
    }
    /// <summary>
    /// Calls <see cref="RandChoice{T}(IRandom, IList{T}, int)"/> with the default RNG instance <see cref="Random"/>.
    /// </summary>
    /// <param name="source">The elements to choose from.</param>
    /// <param name="count">The number of elements to choose.</param>
    /// <typeparam name="T">The type of the elements to be chosen.</typeparam>
    /// <returns>The chosen element.</returns>
    [Obsolete("Consider to use the EmpiricalUniform distribution class")]
    public IEnumerable<T> RandChoice<T>(IList<T> source, int count) {
      return RandChoice(Random, source, count);
    }

    /// <summary>
    /// Generates a random sample from a given source
    /// </summary>
    /// <typeparam name="T">The type of the element in parameter source</typeparam>
    /// <exception cref="ArgumentException">
    /// Thrown when <paramref name="source"/> and <paramref name="weights"/> have different size.
    /// or when <paramref name="weights"/> contains an invalid or negative value.
    /// or when <paramref name="weights"/> sum equals zero or an invalid value.
    /// </exception>
    /// <param name="random">The random number generator to use.</param>
    /// <param name="source">a random sample is generated from its elements.</param>
    /// <param name="weights">The weight associated with each entry in source.</param>
    /// <returns>The generated random samples</returns>
    [Obsolete("Consider to use the EmpiricalNonUniform distribution class")]
    public T RandChoice<T>(IRandom random, IList<T> source, IList<double> weights) {
      return EmpiricalNonUniform<T>.Sample(random, source, weights);
    }
    /// <summary>
    /// Generates a random sample from a given source
    /// </summary>
    /// <typeparam name="T">The type of the element in parameter source</typeparam>
    /// <exception cref="ArgumentException">
    /// Thrown when <paramref name="source"/> and <paramref name="weights"/> have different size.
    /// or when <paramref name="weights"/> contains an invalid or negative value.
    /// or when <paramref name="weights"/> sum equals zero
    /// </exception>
    /// <param name="source">a random sample is generated from its elements.</param>
    /// <param name="weights">The weight associated with each entry in source.</param>
    /// <returns>The generated random samples</returns>
    [Obsolete("Consider to use the EmpiricalNonUniform distribution class")]
    public T RandChoice<T>(IList<T> source, IList<double> weights) {
      return RandChoice<T>(Random, source, weights);
    }

    /// <summary>
    /// This methods chooses a single element from <paramref name="source"/> randomly and by only enumerating
    /// the elements.
    /// </summary>
    /// <remarks>
    /// The preferred and faster method is <see cref="RandChoice{T}(IRandom, IList{T})"/>. Use of this method should
    /// be limited to cases where it is undesirable to reserve a contiguous block of memory for <paramref name="source"/>.
    ///
    /// This method iterates over all elements and calls the RNG each time, thus runtime complexity is O(N).
    /// </remarks>
    /// <param name="random">The random number generator to use.</param>
    /// <param name="source">The elements to choose from.</param>
    /// <typeparam name="T">The type of the elements to be chosen.</typeparam>
    /// <returns>The chosen element.</returns>
    [Obsolete("Consider to use EmpiricalUniform.SampleOnline")]
    public T RandChoiceOnline<T>(IRandom random, IEnumerable<T> source) {
      return EmpiricalUniform<T>.SampleOnline(random, source);
    }
    /// <summary>
    /// Calls <see cref="RandChoiceOnline{T}(IRandom, IEnumerable{T})"/> with the default RNG instance <see cref="Random"/>.
    /// </summary>
    /// <remarks>
    /// The preferred and faster method is <see cref="RandChoice{T}(IList{T})"/>. Use of this method should
    /// be limited to cases where it is undesirable to reserve a contiguous block of memory for <paramref name="source"/>.
    ///
    /// This method iterates over all elements and calls the RNG each time, thus runtime complexity is O(N).
    /// </remarks>
    /// <param name="source">The elements to choose from.</param>
    /// <typeparam name="T">The type of the elements to be chosen.</typeparam>
    /// <returns>The chosen element.</returns>
    [Obsolete("Consider to use the UniformAny distribution")]
    public T RandChoiceOnline<T>(IEnumerable<T> source) {
      return RandChoiceOnline<T>(Random, source);
    }

    /// <summary>
    /// This methods chooses <paramref name="count"/> element from <paramref name="source"/> randomly and by only enumerating
    /// the elements.
    /// </summary>
    /// <remarks>
    /// The preferred and faster method is <see cref="RandChoice{T}(IRandom, IList{T}, int)"/>. Use of this method should
    /// be limited to cases where it is undesirable to reserve a contiguous block of memory for <paramref name="source"/>.
    /// However, the method itself reserves an array of length <paramref name="count"/> and uses a single pass of all elements
    /// in <parmaref name="source"/>.
    ///
    /// Using a count of 0 is possible and will return an empty enumerable.
    ///
    /// For selecting M from a source of N elements runtime complexity is O(N*M). The random number generator will also be called M*N times.
    /// </remarks>
    /// <exception cref="ArgumentException">Thrown when <paramref name="count"/> is negative.</exception>
    /// <param name="random">The random number generator to use.</param>
    /// <param name="source">The elements to choose from.</param>
    /// <param name="count">The number of elements to choose.</param>
    /// <typeparam name="T">The type of the elements to be chosen.</typeparam>
    /// <returns>An enumeration of the chosen elements.</returns>
    [Obsolete("Consider to use EmpiricalUniform.SampleOnline")]
    public IEnumerable<T> RandChoiceOnline<T>(IRandom random, IEnumerable<T> source, int count) {
      return EmpiricalUniform<T>.SampleOnline(random, source, count);
    }
    /// <summary>
    /// Calls <see cref="RandChoiceOnline{T}(IRandom, IEnumerable{T}, int)"/> with the default RNG instance <see cref="Random"/>.
    /// </summary>
    /// <remarks>
    /// The preferred and faster method is <see cref="RandChoice{T}(IList{T}, int)"/>. Use of this method should
    /// be limited to cases where it is undesirable to reserve a contiguous block of memory for <paramref name="source"/>.
    /// However, the method itself reserves an array of length <paramref name="count"/> and uses a single pass of all elements
    /// in <parmaref name="source"/>.
    ///
    /// Using a count of 0 is possible and will return an empty enumerable.
    ///
    /// For selecting M from a source of N elements runtime complexity is O(N*M). The random number generator will also be called M*N times.
    /// </remarks>
    /// <param name="source">The elements to choose from.</param>
    /// <param name="count">The number of elements to choose.</param>
    /// <typeparam name="T">The type of the elements to be chosen.</typeparam>
    /// <returns>An enumeration of the chosen elements.</returns>
    [Obsolete("Consider to use the EmpiricalUniform distribution")]
    public IEnumerable<T> RandChoiceOnline<T>(IEnumerable<T> source, int count) {
      return RandChoiceOnline<T>(Random, source, count);
    }

    /// <summary>
    /// This method chooses <paramref name="count"/> elements from <parameref name="source"/> such that
    /// no element is selected twice. Respectively, elements that are M times in the source may also
    /// be selected up to M times.
    /// </summary>
    /// <remarks>
    /// The method is implemented to iterate over all elements respectively until <paramref name="count"/> elements
    /// are selected. Runtime complexity for selecting M out of a list of N elements is thus O(N).
    ///
    /// Order is preserved, the items are returned in the same relative order as they appear in <paramref name="source"/>.
    ///
    /// Parameter <paramref name="count"/> can be 0 in which case the enumerable will be empty.
    /// </remarks>
    /// <exception cref="ArgumentException">
    /// Thrown when <paramref name="count"/> is negative or when there are not enough items in <paramerf name="source"/>
    /// to choose from.
    /// </exception>
    /// <param name="random">The random number generator to use.</param>
    /// <param name="source">The elements to choose from.</param>
    /// <param name="count">The number of elements to choose.</param>
    /// <returns>An enumeration of the elements.</returns>
    [Obsolete("Consider to use EmpiricalUniform.SampleNoRepetition or the online static method")]
    public IEnumerable<T> RandChoiceNoRepetition<T>(IRandom random, IEnumerable<T> source, int count) {
      return EmpiricalUniform<T>.SampleOnlineNoRepetition(random, source, count);
    }
    /// <summary>
    /// Calls <see cref="RandChoiceNoRepetition{T}(IRandom, IEnumerable{T}, int)"/> with the default RNG instance <see cref="Random"/>.
    /// </summary>
    /// <remarks>
    /// The method is implemented to iterate over all elements respectively until <paramref name="count"/> elements
    /// are selected. Runtime complexity for selecting M out of a list of N elements is thus O(N).
    ///
    /// Order is preserved, the items are returned in the same relative order as they appear in <paramref name="source"/>.
    ///
    /// Parameter <paramref name="count"/> can be 0 in which case the enumerable will be empty.
    /// </remarks>
    /// <exception cref="ArgumentException">
    /// Thrown when <paramref name="count"/> is negative or when there are not enough items in <paramerf name="source"/>
    /// to choose from.
    /// </exception>
    /// <param name="source">The elements to choose from without repetition.</param>
    /// <param name="count">The number of elements that should be chosen.</param>
    /// <typeparam name="T">The type of elements to be chosen.</typeparam>
    /// <returns>An enumeration of the elements.</returns>
    [Obsolete("Consider to use the EmpiricalUniform distribution")]
    public IEnumerable<T> RandChoiceNoRepetition<T>(IEnumerable<T> source, int count) {
      return RandChoiceNoRepetition<T>(Random, source, count);
    }
    #endregion
    #endregion

    #region Random timeouts
    /// <summary>
    /// This method samples a timeout from the given distribution and expects the duration in units of defaultstep.
    /// </summary>
    /// <param name="random">The pseudo random number generator to use</param>
    /// <param name="duration">The duration distribution in units of defaultstep (defaults to 1 unit = 1 second)</param>
    /// <returns>The timeout event</returns>
    public Timeout TimeoutD(IRandom random, IDistribution<double> duration) {
      return new Timeout(this, ToTimeSpan(duration.Sample(random)));
    }
    /// <summary>
    /// This method samples a timeout from the given distribution and expects the duration in units of defaultstep.
    ///
    /// It uses the default random number generator instance of this class.
    /// </summary>
    /// <param name="duration">The duration distribution in units of defaultstep (defaults to 1 unit = 1 second)</param>
    /// <returns>The timeout event</returns>
    public Timeout TimeoutD(IDistribution<double> duration) {
      return TimeoutD(Random, duration);
    }
    /// <summary>
    /// This method creates a timeout sampled from a distribution in the TimeSpan domain.
    /// </summary>
    /// <param name="random">The pseudo random number generator to use</param>
    /// <param name="duration">The duration distribution in units of seconds</param>
    /// <returns>The timeout event</returns>
    public Timeout Timeout(IRandom random, IDistribution<TimeSpan> duration) {
      return new Timeout(this, duration.Sample(random));
    }
    /// <summary>
    /// This method creates a timeout sampled from a distribution in the TimeSpan domain.
    ///
    /// It uses the default random number generator instance of this class.
    /// </summary>
    /// <param name="duration">The duration distribution in units of seconds</param>
    /// <returns>The timeout event</returns>
    public Timeout Timeout(IDistribution<TimeSpan> duration) {
      return new Timeout(this, duration.Sample(Random));
    }

    #region Obsolete code
    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutUniformD(IRandom random, double a, double b) {
      return new Timeout(this, ToTimeSpan(RandUniform(random, a, b)));
    }
    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutUniformD(double a, double b) {
      return TimeoutUniformD(Random, a, b);
    }

    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutUniform(IRandom random, TimeSpan a, TimeSpan b) {
      return new Timeout(this, RandUniform(random, a, b));
    }
    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutUniform(TimeSpan a, TimeSpan b) {
      return TimeoutUniform(Random, a, b);
    }

    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutTriangularD(IRandom random, double low, double high) {
      return new Timeout(this, ToTimeSpan(RandTriangular(random, low, high)));
    }
    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutTriangularD(double low, double high) {
      return TimeoutTriangularD(Random, low, high);
    }

    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutTriangular(IRandom random, TimeSpan low, TimeSpan high) {
      return new Timeout(this, RandTriangular(random, low, high));
    }
    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutTriangular(TimeSpan low, TimeSpan high) {
      return TimeoutTriangular(Random, low, high);
    }

    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutTriangularD(IRandom random, double low, double high, double mode) {
      return new Timeout(this, ToTimeSpan(RandTriangular(random, low, high, mode)));
    }
    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutTriangularD(double low, double high, double mode) {
      return TimeoutTriangularD(Random, low, high, mode);
    }

    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutTriangular(IRandom random, TimeSpan low, TimeSpan high, TimeSpan mode) {
      return new Timeout(this, RandTriangular(random, low, high, mode));
    }
    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutTriangular(TimeSpan low, TimeSpan high, TimeSpan mode) {
      return TimeoutTriangular(Random, low, high, mode);
    }

    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutExponentialD(IRandom random, double mean) {
      return new Timeout(this, ToTimeSpan(RandExponential(random, mean)));
    }
    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutExponentialD(double mean) {
      return TimeoutExponentialD(Random, mean);
    }

    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutExponential(IRandom random, TimeSpan mean) {
      return new Timeout(this, RandExponential(random, mean));
    }
    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutExponential(TimeSpan mean) {
      return TimeoutExponential(Random, mean);
    }

    [Obsolete("Consider to use TimeoutRandom with the bounded distribution class")]
    public Timeout TimeoutNormalPositiveD(IRandom random, double mu, double sigma) {
      return new Timeout(this, ToTimeSpan(RandNormalPositive(random, mu, sigma)));
    }
    [Obsolete("Consider to use TimeoutRandom with the bounded distribution class")]
    public Timeout TimeoutNormalPositiveD(double mu, double sigma) {
      return TimeoutNormalPositiveD(Random, mu, sigma);
    }

    [Obsolete("Consider to use TimeoutRandom with the bounded distribution class")]
    public Timeout TimeoutNormalPositive(IRandom random, TimeSpan mu, TimeSpan sigma) {
      return new Timeout(this, RandNormalPositive(random, mu, sigma));
    }
    [Obsolete("Consider to use TimeoutRandom with the bounded distribution class")]
    public Timeout TimeoutNormalPositive(TimeSpan mu, TimeSpan sigma) {
      return TimeoutNormalPositive(Random, mu, sigma);
    }

    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutLogNormalD(IRandom random, double mu, double sigma) {
      return new Timeout(this, ToTimeSpan(RandLogNormal(random, mu, sigma)));
    }
    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutLogNormalD(double mu, double sigma) {
      return TimeoutLogNormalD(Random, mu, sigma);
    }

    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutLogNormal2D(IRandom random, double mean, double stdev) {
      return new Timeout(this, ToTimeSpan(RandLogNormal2(random, mean, stdev)));
    }
    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutLogNormal2D(double mean, double stdev) {
      return TimeoutLogNormal2D(Random, mean, stdev);
    }

    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutLogNormal(IRandom random, TimeSpan mu, TimeSpan sigma) {
      return new Timeout(this, RandLogNormal(random, mu, sigma));
    }
    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutLogNormal(TimeSpan mu, TimeSpan sigma) {
      return TimeoutLogNormal(Random, mu, sigma);
    }

    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutLogNormal2(IRandom random, TimeSpan mean, TimeSpan stdev) {
      return new Timeout(this, RandLogNormal2(random, mean, stdev));
    }
    [Obsolete("Consider to use TimeoutRandom with an appropriate distribution class")]
    public Timeout TimeoutLogNormal2(TimeSpan mean, TimeSpan stdev) {
      return TimeoutLogNormal2(Random, mean, stdev);
    }
    #endregion
    #endregion
  }

  /// <summary>
  /// Provides a simulation environment that is thread-safe against manipulations of the event queue.
  /// Its performance is somewhat lower than the non-thread-safe environment (cf. <see cref="Simulation"/>)
  /// due to the locking involved.
  /// </summary>
  /// <remarks>
  /// Please carefully consider if you must really schedule the stop event in a separate thread. You can also
  /// call <see cref="Simulation.StopAsync"/> to request termination after the current event has been processed.
  ///
  /// The simulation will still run in only one thread and execute all events sequentially.
  /// </remarks>
  public class ThreadSafeSimulation : Simulation {
    protected object _locker;

    public ThreadSafeSimulation() : this(new DateTime(1970, 1, 1)) { }
    public ThreadSafeSimulation(TimeSpan? defaultStep) : this(new DateTime(1970, 1, 1), defaultStep) { }
    public ThreadSafeSimulation(DateTime initialDateTime, TimeSpan? defaultStep = null) : this(new PcgRandom(), initialDateTime, defaultStep) { }
    public ThreadSafeSimulation(int randomSeed, TimeSpan? defaultStep = null) : this(new DateTime(1970, 1, 1), randomSeed, defaultStep) { }
    public ThreadSafeSimulation(DateTime initialDateTime, int randomSeed, TimeSpan? defaultStep = null) : this(new PcgRandom(randomSeed), initialDateTime, defaultStep) { }
    public ThreadSafeSimulation(IRandom random, DateTime initialDateTime, TimeSpan? defaultStep = null) : base(random, initialDateTime, defaultStep) {
      _locker = new object();
    }

    /// <summary>
    /// Schedules an event to occur at the same simulation time as the call was made.
    /// </summary>
    /// <remarks>
    /// This method is thread-safe against manipulations of the event queue
    /// </remarks>
    /// <param name="event">The event that should be scheduled.</param>
    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
    public override void Schedule(Event @event, int priority = 0) {
      lock (_locker) {
        DoSchedule(Now, @event, priority);
      }
    }

    /// <summary>
    /// Schedules an event to occur after a certain (positive) delay.
    /// </summary>
    /// <remarks>
    /// This method is thread-safe against manipulations of the event queue
    /// </remarks>
    /// <exception cref="ArgumentException">
    /// Thrown when <paramref name="delay"/> is negative.
    /// </exception>
    /// <param name="delay">The (positive) delay after which the event should be fired.</param>
    /// <param name="event">The event that should be scheduled.</param>
    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
    public override void Schedule(TimeSpan delay, Event @event, int priority = 0) {
      if (delay < TimeSpan.Zero)
        throw new ArgumentException("Negative delays are not allowed in Schedule(TimeSpan, Event).");
      lock (_locker) {
        var eventTime = Now + delay;
        DoSchedule(eventTime, @event, priority);
      }
    }

    /// <summary>
    /// Run until a certain event is processed.
    /// </summary>
    /// <remarks>
    /// This method is thread-safe against manipulations of the event queue
    /// </remarks>
    /// <param name="stopEvent">The event that stops the simulation.</param>
    /// <returns></returns>
    public override object Run(Event stopEvent = null) {
      _stop = new CancellationTokenSource();
      if (stopEvent != null) {
        if (stopEvent.IsProcessed) {
          return stopEvent.Value;
        }
        stopEvent.AddCallback(StopSimulation);
      }
      OnRunStarted();
      try {
        var stop = false;
        lock (_locker) {
          stop = ScheduleQ.Count == 0 || _stop.IsCancellationRequested;
        }
        while (!stop) {
          Step();
          lock (_locker) {
            stop = ScheduleQ.Count == 0 || _stop.IsCancellationRequested;
          }
        }
      } catch (StopSimulationException e) { OnRunFinished(); return e.Value; }
      OnRunFinished();
      if (stopEvent == null) return null;
      if (!_stop.IsCancellationRequested && !stopEvent.IsTriggered) throw new InvalidOperationException("No scheduled events left but \"until\" event was not triggered.");
      return stopEvent.Value;
    }

    public Task<object> RunAsync(TimeSpan duration) {
      return Task.Run(() => Run(duration));
    }

    public Task<object> RunAsync(DateTime until) {
      return Task.Run(() => Run(until));
    }

    /// <summary>
    /// Run until a certain event is processed, but does not block.
    /// </summary>
    /// <param name="stopEvent">The event that stops the simulation.</param>
    /// <returns></returns>
    public Task<object> RunAsync(Event stopEvent = null) {
      return Task.Run(() => Run(stopEvent));
    }

    /// <summary>
    /// Performs a single step of the simulation, i.e. process a single event
    /// </summary>
    /// <remarks>
    /// This method is thread-safe against manipulations of the event queue
    /// </remarks>
    public override void Step() {
      Event evt;
      lock (_locker) {
        var next = ScheduleQ.Dequeue();
        Now = next.PrimaryPriority;
        evt = next.Event;
      }
      evt.Process();
      ProcessedEvents++;
    }

    /// <summary>
    /// Peeks at the time of the next event in terms of the defined step
    /// </summary>
    /// <remarks>
    /// This method is thread-safe against manipulations of the event queue
    /// </remarks>
    public override double PeekD() {
      lock (_locker) {
        if (ScheduleQ.Count == 0) return double.MaxValue;
        return (Peek() - StartDate).TotalSeconds / DefaultTimeStepSeconds;
      }
    }

    /// <summary>
    /// Peeks at the time of the next event
    /// </summary>
    /// <remarks>
    /// This method is thread-safe against manipulations of the event queue
    /// </remarks>
    public override DateTime Peek() {
      lock (_locker) {
        return ScheduleQ.Count > 0 ? ScheduleQ.First.PrimaryPriority : DateTime.MaxValue;
      }
    }
  }

  /// <summary>
  /// Provides a simulation environment where delays in simulation time may result in a similar
  /// delay in wall-clock time. The environment is not an actual realtime simulation environment
  /// in that there is no guarantee that 3 seconds in model time are also exactly 3 seconds in
  /// observed wall-clock time. This simulation environment is a bit slower, as the overhead of
  /// the simulation kernel (event creation, queuing, processing, etc.) is not accounted for.
  ///
  /// However, it features a switch between virtual and realtime, thus allowing it to be used
  /// in contexts where realtime is only necessary sometimes (e.g. during interaction with
  /// long-running co-processes). Such use cases may arise in simulation control problems.
  /// </summary>
  public class PseudoRealtimeSimulation : ThreadSafeSimulation {
    public const double DefaultRealtimeScale = 1;

    /// <summary>
    /// The scale at which the simulation runs in comparison to realtime. A value smaller
    /// than 1 results in longer-than-realtime delays, while a value larger than 1 results
    /// in shorter-than-realtime delays. A value of exactly 1 is realtime.
    /// </summary>
    public double? RealtimeScale { get; protected set; } = DefaultRealtimeScale;
    /// <summary>
    /// Whether a non-null <see cref="RealtimeScale"/> has been set.
    /// </summary>
    public bool IsRunningInRealtime => RealtimeScale.HasValue;

    private object _timeLocker = new object();
    /// <summary>
    /// The current model time. Note that, while in realtime, this may continuously change.
    /// </summary>
    public override DateTime Now {
      get {
        lock (_timeLocker) {
          if (!IsRunningInRealtime) return base.Now;
          return base.Now + TimeSpan.FromMilliseconds(_rtDelayTime.Elapsed.TotalMilliseconds * RealtimeScale.Value);
        }
      }
      protected set => base.Now = value;
    }

    protected CancellationTokenSource _rtDelayCtrl = null;
    protected Stopwatch _rtDelayTime = new Stopwatch();

    public PseudoRealtimeSimulation() : this(new DateTime(1970, 1, 1)) { }
    public PseudoRealtimeSimulation(TimeSpan? defaultStep) : this(new DateTime(1970, 1, 1), defaultStep) { }
    public PseudoRealtimeSimulation(DateTime initialDateTime, TimeSpan? defaultStep = null) : this(new PcgRandom(), initialDateTime, defaultStep) { }
    public PseudoRealtimeSimulation(int randomSeed, TimeSpan? defaultStep = null) : this(new DateTime(1970, 1, 1), randomSeed, defaultStep) { }
    public PseudoRealtimeSimulation(DateTime initialDateTime, int randomSeed, TimeSpan? defaultStep = null) : this(new PcgRandom(randomSeed), initialDateTime, defaultStep) { }
    public PseudoRealtimeSimulation(IRandom random, DateTime initialDateTime, TimeSpan? defaultStep = null) : base(random, initialDateTime, defaultStep) { }

    protected override EventQueueNode DoSchedule(DateTime date, Event @event, int priority = 0) {
      if (ScheduleQ.Count > 0 && date < ScheduleQ.First.PrimaryPriority) _rtDelayCtrl?.Cancel();
      return base.DoSchedule(date, @event, priority);
    }

    public override void Step() {
      var delay = TimeSpan.Zero;
      double? rtScale = null;
      lock (_locker) {
        if (IsRunningInRealtime) {
          rtScale = RealtimeScale;
          var next = ScheduleQ.First.PrimaryPriority;
          delay = next - base.Now;
          if (rtScale.Value != 1.0) delay = TimeSpan.FromMilliseconds(delay.TotalMilliseconds / rtScale.Value);
          _rtDelayCtrl = CancellationTokenSource.CreateLinkedTokenSource(_stop.Token);
        }
      }

      if (delay > TimeSpan.Zero) {
        _rtDelayTime.Start();
        Task.Delay(delay, _rtDelayCtrl.Token).ContinueWith(_ => { }).Wait();
        _rtDelayTime.Stop();
        var observed = _rtDelayTime.Elapsed;

        lock (_locker) {
          if (rtScale.Value != 1.0) observed = TimeSpan.FromMilliseconds(observed.TotalMilliseconds * rtScale.Value);
          if (_rtDelayCtrl.IsCancellationRequested && observed < delay) {
            lock (_timeLocker) {
              Now = base.Now + observed;
              _rtDelayTime.Reset();
            }
            return; // next event is not processed, step is not actually completed
          }
        }
      }

      Event evt;
      lock (_locker) {
        var next = ScheduleQ.Dequeue();
        lock (_timeLocker) {
          _rtDelayTime.Reset();
          Now = next.PrimaryPriority;
        }
        evt = next.Event;
      }
      evt.Process();
      ProcessedEvents++;
    }

    /// <summary>
    /// Switches the simulation to virtual time mode, i.e., running as fast as possible.
    /// In this mode, events are processed without delay just like in a <see cref="ThreadSafeSimulation"/>.
    /// </summary>
    /// <remarks>
    /// An ongoing real-time delay is being canceled when this method is called. Usually, this
    /// is only the case when this method is called from a thread other than the main simulation thread.
    ///
    /// If the simulation is already in virtual time mode, this method has no effect.
    /// </remarks>
    public virtual void SetVirtualtime() {
      lock (_locker) {
        if (!IsRunningInRealtime) return;
        RealtimeScale = null;
        _rtDelayCtrl?.Cancel();
      }
    }

    /// <summary>
    /// Switches the simulation to real time mode. The real time factor of
    /// this default mode is configurable.
    /// </summary>
    /// <remarks>
    /// If this method is called while running in real-time mode, but given a different
    /// <paramref name="realtimeScale"/>, the current delay is canceled and the remaining
    /// time is delayed using the new time factor.
    ///
    /// The default factor is 1, i.e., real time - a timeout of 5 seconds would cause
    /// a wall-clock delay of 5 seconds. With a factor of 2, the delay as measured by
    /// a wall clock would be 2.5 seconds, whereas a factor of 0.5, a wall-clock delay of
    /// 10 seconds would be observed.
    /// </remarks>
    /// <param name="realtimeScale">A value strictly greater than 0 used to scale real time events.</param>
    public virtual void SetRealtime(double realtimeScale = DefaultRealtimeScale) {
      lock (_locker) {
        if (realtimeScale <= 0.0) throw new ArgumentException("The simulation speed scaling factor must be strictly positive.", nameof(realtimeScale));
        if (IsRunningInRealtime && realtimeScale != RealtimeScale) _rtDelayCtrl?.Cancel();
        RealtimeScale = realtimeScale;
      }
    }

    /// <summary>
    /// This is only a convenience for mixed real- and virtual time simulations.
    /// It creates a new pseudo realtime process which will set the simulation
    /// to realtime every time it continues (e.g., if it has been set to virtual time).
    /// The process is automatically scheduled to be started at the current simulation time.
    /// </summary>
    /// <param name="generator">The generator function that represents the process.</param>
    /// <param name="priority">The priority to rank events at the same time (smaller value = higher priority).</param>
    /// <param name="realtimeScale">A value strictly greater than 0 used to scale real time events (1 = realtime).</param>
    /// <returns>The scheduled process that was created.</returns>
    public Process PseudoRealtimeProcess(IEnumerable<Event> generator, int priority = 0, double realtimeScale = DefaultRealtimeScale) {
      return new PseudoRealtimeProcess(this, generator, priority, realtimeScale);
    }
  }

  /// <summary>
  /// Environments hold the event queues, schedule and process events.
  /// </summary>
  [Obsolete("Use class Simulation or ThreadSafeSimulation instead. Due to name clashes with System.Environment the class SimSharp.Environment is being outphased.")]
  public class Environment : ThreadSafeSimulation {
    public Environment()
      : base() {
      Random = new SystemRandom();
    }
    public Environment(TimeSpan? defaultStep)
      : base(defaultStep) {
      Random = new SystemRandom();
    }
    public Environment(int randomSeed, TimeSpan? defaultStep = null)
      : base(randomSeed, defaultStep) {
      Random = new SystemRandom(randomSeed);
    }
    public Environment(DateTime initialDateTime, TimeSpan? defaultStep = null)
      : base(initialDateTime, defaultStep) {
      Random = new SystemRandom();
    }
    public Environment(DateTime initialDateTime, int randomSeed, TimeSpan? defaultStep = null)
      : base(initialDateTime, randomSeed, defaultStep) {
      Random = new SystemRandom(randomSeed);
    }

    protected static readonly double NormalMagicConst = 4 * Math.Exp(-0.5) / Math.Sqrt(2.0);
    [Obsolete("Use the new Normal distribution class")]
    public override double RandNormal(double mu, double sigma) {
      return RandNormal(Random, mu, sigma);
    }
    [Obsolete("Use the new Normal distribution class")]
    public override double RandNormal(IRandom random, double mu, double sigma) {
      double z, zz, u1, u2;
      do {
        u1 = random.NextDouble();
        u2 = 1 - random.NextDouble();
        z = NormalMagicConst * (u1 - 0.5) / u2;
        zz = z * z / 4.0;
      } while (zz > -Math.Log(u2));
      return mu + z * sigma;
    }
  }
}

redpajama_set_name: RedPajamaGithub


We want to help teachers manage their classroom – the way they want. For free.
Why you should be cautious online, even when interacting with your peers.
Find out how schools can utilize web filtering to protect students of all ages, and optimize the digital classroom.
The world's leading provider of cloud-based online security for the K-12 environment releases a self-serve tool to streamline the web filter setup process.
Cyberbullying and self-harm prevention solutions based on real time data from social media trends across the country.
Securly's new blacklist feature takes web filtering to the next level for schools and parents by more efficiently blocking inappropriate content.
Securly now works with iKeepSafe and IWF to ensure online child safety and protect student privacy.
Best practices to optimize your school's 1:1 chromebook program, ensuring the online safety and security of your students.
Students share how they would improve web filtering for schools and online safety measures.


text:
Title: Saint-Étienne
Subject: A72 autoroute, 1998 FIFA World Cup, Rhône-Alpes, Société de Transports de l'Agglomération Stéphanoise, École nationale d'ingénieurs de Saint-Etienne
Collection: Communes of Loire (Department), Massif Central, Prefectures in France, Saint-Étienne
Location within Rhône-Alpes region
Capital of 9 cantons
Intercommunality
• Mayor (2014-2020)
Gaël Perdriau (UMP)
Population (2007 estimate)2
16th in France
CET (GMT +1)
INSEE/Postal code
42218 / 42000, 42100
422–1,117 m (1,385–3,665 ft)
(avg. 516 m or 1,693 ft)
http://www.saint-etienne.fr/
1 French Land Register data, which excludes lakes, ponds, glaciers > 1 km² (0.386 sq mi or 247 acres) and river estuaries.
2 Population without double counting: residents of multiple communes (e.g., students and military personnel) only counted once.
Saint-Étienne (French pronunciation: ; Arpitan: Sant-Etiève; Saint Stephen) is a city in eastern central France. It is located in the Massif Central, 50 km (31 mi) southwest of Lyon in the Rhône-Alpes region, along the trunk road that connects Toulouse with Lyon. Saint-Étienne is the capital of the Loire department and has a population of approximately 178,500 in the city itself and over 508,000 in the metropolitan area (2011).
Colleges and universities 6
Notable people 7
Named after Saint Stephen, the city first appears in the historical record in the Middle Ages as Saint-Étienne de Furan (after the River Furan, a tributary of the Loire). In the 13th century it was a small borough around the church dedicated to Saint Etienne. On the upper reaches of the Furan near the Way of St. James the Abbey of Valbenoîte had been founded by the cistercians in 1222. In the late 15th century it was a fortified village defended by walls built around the original nucleus.
From the 16th century, Saint-Étienne developed an arms manufacturing industry and became a market town. It was this which accounted for the town's importance, although it also became a centre for the manufacture of ribbons and passementerie starting in the 17th century. During the French revolution, Saint-Étienne was briefly renamed Armeville – 'arms town' – because of this activity.
Later, it became a mining centre of the Loire coal mining basin, and more recently has become known for its bicycle industry.
In the first half of the 19th century it was only a chief town of an arrondissement in the département of the Loire, with a population of 33,064 in 1832. The concentration of industry prompted these numbers to rise rapidly to 110,000 by about 1880. It was this growing importance of Saint-Étienne that led to its being made seat of the prefecture and the departmental administration on 25 July 1855, when it became the chief town in the département and seat of the prefect, replacing Montbrison, which was reduced to the status of chief town of an arrondissement. Saint-Étienne absorbed the commune of Valbenoîte and several other neighbouring localities on 31 March 1855.
Population of the city at the 1999 census was 180,210 (177,300 as of February 2004 estimates). Population of the whole metropolitan area at the 1999 census was 321,703.
Inhabitants of Saint-Étienne are called Stéphanois in French. They are named so because "Étienne" derives from the Greek Stephanos.
Saint-Étienne became a popular stop for automobile travelers in the early 20th century (sometimes referred to as The Golden Age of Travel[1]).
In 1990 Saint-Étienne set up a design biennale – the largest of its kind in France. It lasts around two weeks. The last convention was in March 2013.[2] A landmark in the history of the importance ascribed to design in Saint-Étienne was the inauguration of La Cité du design on the site of the former arms factory in 2009.
The city also launched the Massenet Festivals, (the composer Jules Massenet hailed from the area) devoted mainly to perform Massenet's operas. In 2000 the city was named one of the French Towns and Lands of Art and History. On 22 November 2010, it was nominated as "City of Design" as part of Unesco's Creative Cities Network.[3]
Saint-Étienne has three museums:
the Musée d'Art Moderne has one of the largest collections of modern and contemporary art in France
Musée de la Mine
Musée de l'Art et de l'Industrie
The city's football club AS Saint-Étienne has won the Ligue 1 title a record ten times, achieving most of their success in the 1970s. British indie-dance band Saint Etienne named themselves after the club.
St. Étienne was the capital of the French bicycle industry. The bicycle wheel manufacturer Mavic is based in the city and frame manufacturers Motobécane and Vitus are also based here. The city often hosts a stage of the Tour de France.
St. Étienne resident orienteering. The local rugby union team is CA Saint-Étienne Loire Sud Rugby.
Street tram in the city
Tramway, bus and bicycles run by STAS (Société de Transports de l'Agglomération Stéphanoise)
Rochetaillée castle
View of Saint-Étienne
The nearest airport is Saint-Étienne - Bouthéon Airport which is located in Andrézieux-Bouthéon, 12 km (7.46 mi) north-northwest of Saint-Étienne. The main railway station is Gare de Saint-Étienne-Châteaucreux, which offers high speed services to Paris and Lyon (Saint-Étienne–Lyon railway) and several regional lines.
Saint-Étienne is also notable for its tramway (Saint-Étienne tramway) – which uniquely with Lille, it kept throughout the 20th century – and its trolleybus system (Saint-Étienne trolleybus system) – which is one of only three such systems currently operating in France.
Bus and tram transport is regulated and provided by the Société de Transports de l'Agglomération Stéphanoise (STAS), a public transport executive organisation.
The bicycle sharing system Vélivert with 280 short term renting bicycles is available since June 2010.
Jean Monnet University
École Nationale Supérieure des Mines de Saint-Étienne (EMSE or ENSMSE)
École nationale d'ingénieurs de Saint-Étienne (ENISE)
Telecom Saint Etienne (TSE)
ESC Saint-Etienne
ENSASE (Ecole National Supérieure d'Architecture de Saint-Étienne)
Saint-Étienne was the birthplace of
René Diaz - French journalist and illustrator
Augustin Dupré (1748–1833) engraver of French coins and medals, France's 14th Graveur général des monnaies
Claude Fauriel (1772–1844), historian, philologist and critic.
Saint Marcellin Champagnat (1789–1840), a Catholic priest and founding members of the Society of Mary (Marist Fathers) who founded the Marist Brothers and was canonised in 1999.
Antonin Moine (1796–1849), sculptor
Jules Janin (1804–1874), writer and critic.
Francis Garnier (1839–1873), officer and explorer who explored the Mekong River, much to the surprise of the inhabitants.
Jules Massenet (1842–1912), composer best known for his operas.
Paul de Vivie, aka Velocio (1853–1930) publisher of Le Cycliste, early champion of the dérailleur and father of French cycle touring.
Claudine Chomat (1915–1995), member of the French Resistance during World War II, feminist, communist activist
Bernard Lavilliers (b. 1946) (Bernard Ouillon), singer.
Orlan (1947–), contemporary artist
Willy Sagnol (b. 1977) French International Football Player
Jean Guitton (1901–1999) a Catholic philosopher and theologian.
Orienteering world champion
Norma Ray singer
Alexis Ajinca basketball player
Sylvain Armand footballer
Sliimy singer
Aravane Rezai tennis player
Loïc Perrin footballer
Aurélien Rodot, creator of Gamebuino, an open source Arduino-based games console
It was also the place where Andrei Kivilev died.
Saint-Étienne is twinned with:
Annaba, Algeria, since 1982
Ben Arous, Tunisia, since 1994
Bobo Dioulasso, Burkina Faso, since 2009
Coventry, United Kingdom, since 1955[4][5][6]
Des Moines, United States, since 1984
Ferrara, Italy, since 1960
Geltendorf, Germany, since 1966
Granby, Canada, since 1960
Katowice, Poland, since 1994
Luhansk, Ukraine, since 1959
Monastir, Tunisia, since 2012
Nazareth Illit, Israel, since 1974
Oeiras, Portugal, since 1995
Patras, Greece, since 1990
Toamasina, Madagascar, since 1967
Windsor, Canada, since 1963
Wuppertal, Germany, since 1960
Xúzhōu, China, since 1984
Manufacture d'armes de Saint-Étienne
Stade Geoffroy-Guichard
Saint-Étienne Cathedral
Saint-Étienne – Gorges de la Loire Nature Reserve
André César Vermare Sculptor of Franco-Prussian war memorial.
Creative Cities Network
INSEE commune file
^ "LAPL Virtual Photo: Far and Wide". Lapl.org. Retrieved 14 June 2010.
^ "Cité du design | Biennale | L'Édition 2013". Citedudesign.com. Retrieved 2013-03-12.
^ St-Etienne and Sydney nominated UNESCO Creative Cities , 22 November 2010.
^ Griffin, Mary (2011-08-02). "Coventry's twin towns". Coventry Telegraph. Retrieved 2013-08-06.
^ "Coventry - Twin towns and cities". Coventry City nonoCouncil. Archived from the original on 2013-04-14. Retrieved 2013-08-06.
^ "British towns twinned with French towns". Archant Community Media Ltd. Retrieved 2013-07-11.
City council website
Tourist board official website
Local events website
Prefectures of Departments of France
Bourg-en-Bresse (Ain)
Laon (Aisne)
Moulins (Allier)
Digne-les-Bains (Alpes-de-Haute-Provence)
Gap (Hautes-Alpes)
Privas (Ardèche)
Charleville-Mézières (Ardennes)
Foix (Ariège)
Troyes (Aube)
Carcassonne (Aude)
Rodez (Aveyron)
Marseille (Bouches-du-Rhône)
Caen (Calvados)
Aurillac (Cantal)
Angoulême (Charente)
La Rochelle (Charente-Maritime)
Bourges (Cher)
Tulle (Corrèze)
Ajaccio (Corse-du-Sud)
Bastia (Haute-Corse)
Dijon (Côte-d'Or)
Saint-Brieuc (Côtes-d'Armor)
Guéret (Creuse)
Périgueux (Dordogne)
Besançon (Doubs)
Valence (Drôme)
Évreux (Eure)
Chartres (Eure-et-Loir)
Quimper (Finistère)
Nîmes (Gard)
Auch (Gers)
Châteauroux (Indre)
Tours (Indre-et-Loire)
Grenoble (Isère)
Lons-le-Saunier (Jura)
Mont-de-Marsan (Landes)
Blois (Loir-et-Cher)
Saint-Étienne (Loire)
Le Puy-en-Velay (Haute-Loire)
Cahors (Lot)
Agen (Lot-et-Garonne)
Mende (Lozère)
Angers (Maine-et-Loire)
Saint-Lô (Manche)
Châlons-en-Champagne (Marne)
Chaumont (Haute-Marne)
Nancy (Meurthe-et-Moselle)
Bar-le-Duc (Meuse)
Vannes (Morbihan)
Metz (Moselle)
Nevers (Nièvre)
Alençon (Orne)
Arras (Pas-de-Calais)
Clermont-Ferrand (Puy-de-Dôme)
Pau (Pyrénées-Atlantiques)
Tarbes (Hautes-Pyrénées)
Perpignan (Pyrénées-Orientales)
Strasbourg (Bas-Rhin)
Colmar (Haut-Rhin)
Lyon (Rhône)
Mâcon (Saône-et-Loire)
Le Mans (Sarthe)
Chambéry (Savoie)
Paris (Paris)
Rouen (Seine-Maritime)
Melun (Seine-et-Marne)
Versailles (Yvelines)
Amiens (Somme)
Albi (Tarn)
Montauban (Tarn-et-Garonne)
Toulon (Var)
La Roche-sur-Yon (Vendée)
Limoges (Haute-Vienne)
Épinal (Vosges)
Auxerre (Yonne)
Belfort (Territoire de Belfort)
Évry (Essonne)
Nanterre (Hauts-de-Seine)
Bobigny (Seine-Saint-Denis)
Cergy, Pontoise (Val-d'Oise)
Overseas departments
Basse-Terre (Guadeloupe)
Fort-de-France (Martinique)
Cayenne (French Guiana)
Saint-Denis (Réunion)
Mamoudzou (Mayotte)
Communes of the Loire department
Aboën
Ailleux
Amions
Apinac
Arcinges
Arthun
Aveizieux
Balbigny
Bellegarde-en-Forez
Belleroche
Belmont-de-la-Loire
La Bénisson-Dieu
Le Bessat
Boën-sur-Lignon
Boisset-lès-Montrond
Boisset-Saint-Priest
Bourg-Argental
Burdignes
Bussy-Albieux
Çaloire
Cellieu
Le Cergne
Cezay
Chagnon
Chalain-d'Uzore
Chalain-le-Comtal
Chalmazel
La Chamba
Chambéon
Chambles
Chambœuf
Le Chambon-Feugerolles
La Chambonie
Champoly
La Chapelle-en-Lafaye
La Chapelle-Villars
Châtelneuf
Châtelus
Chausseterre
Chavanay
Chazelles-sur-Lavieu
Chazelles-sur-Lyon
Chenereilles
Cherier
Chevrières
Chirassimont
Chuyer
Civens
Cleppé
Combre
Commelle-Vernay
La Côte-en-Couzan
Le Coteau
Cottance
Coutouvre
Craintilleux
Cremeaux
Croizet-sur-Gand
Le Crozet
Cuinzier
Dancé
Dargoire
Débats-Rivière-d'Orpra
Doizieux
Écoche
Écotay-l'Olme
Épercieux-Saint-Paul
Essertines-en-Châtelneuf
Essertines-en-Donzy
Estivareilles
L'Étrat
Farnay
Firminy
Fontanès
La Fouillouse
Fraisses
Genilac
La Gimond
Graix
La Grand-Croix
La Gresle
Grézieux-le-Fromental
Grézolles
Gumières
L'Hôpital-le-Grand
L'Hôpital-sous-Rochefort
L'Horme
Jarnosse
Jeansagnière
Jonzieux
Juré
Lavieu
Leigneux
Lentigny
Lérigneux
Lézigneux
Lupé
Luré
Luriecq
Machézal
Maclas
Magneux-Haute-Rive
Maizilly
Malleval
Marcenod
Marcilly-le-Châtel
Marclopt
Margerie-Chantagret
Marols
Merle-Leignec
Mizérieux
Montarcher
Montchal
Montrond-les-Bains
Montverdun
Mornand-en-Forez
Nandax
Neaux
Néronde
Nervieux
Neulise
Noailly
Les Noës
Noirétable
Nollieux
Notre-Dame-de-Boisset
Palogneux
Panissières
Parigny
Pavezin
La Pacaudière
Pélussin
Périgneux
Perreux
Planfoy
Poncins
Pouilly-lès-Feurs
Pouilly-les-Nonains
Pouilly-sous-Charlieu
Pralong
Régny
Rive-de-Gier
Roche-la-Molière
Roisey
Rozier-Côtes-d'Aurec
Rozier-en-Donzy
Sail-sous-Couzan
Saint-Alban-les-Eaux
Saint-André-d'Apchon
Saint-André-le-Puy
Saint-Appolinard
Saint-Barthélemy-Lestra
Saint-Bonnet-des-Quarts
Saint-Bonnet-le-Château
Saint-Bonnet-le-Courreau
Saint-Bonnet-les-Oules
Saint-Chamond
Saint-Christo-en-Jarez
Saint-Cyr-de-Favières
Saint-Cyr-de-Valorges
Saint-Cyr-les-Vignes
Saint-Denis-de-Cabanne
Saint-Denis-sur-Coise
Saint-Didier-sur-Rochefort
Sainte-Agathe-en-Donzy
Sainte-Agathe-la-Bouteresse
Sainte-Colombe-sur-Gand
Sainte-Croix-en-Jarez
Sainte-Foy-Saint-Sulpice
Saint-Étienne-le-Molard
Saint-Forgeux-Lespinasse
Saint-Genest-Lerpt
Saint-Genest-Malifaux
Saint-Georges-de-Baroille
Saint-Georges-en-Couzan
Saint-Georges-Haute-Ville
Saint-Germain-la-Montagne
Saint-Germain-Lespinasse
Saint-Haon-le-Châtel
Saint-Haon-le-Vieux
Saint-Héand
Saint-Hilaire-Cusson-la-Valmitte
Saint-Hilaire-sous-Charlieu
Saint-Jean-Bonnefonds
Saint-Jean-la-Vêtre
Saint-Jean-Saint-Maurice-sur-Loire
Saint-Jean-Soleymieux
Saint-Jodard
Saint-Julien-d'Oddes
Saint-Julien-la-Vêtre
Saint-Julien-Molin-Molette
Saint-Just-en-Bas
Saint-Just-en-Chevalet
Saint-Just-la-Pendue
Saint-Just-Saint-Rambert
Saint-Laurent-la-Conche
Saint-Laurent-Rochefort
Saint-Léger-sur-Roanne
Saint-Marcel-de-Félines
Saint-Marcel-d'Urfé
Saint-Marcellin-en-Forez
Saint-Martin-d'Estréaux
Saint-Martin-la-Plaine
Saint-Martin-la-Sauveté
Saint-Martin-Lestra
Saint-Maurice-en-Gourgois
Saint-Médard-en-Forez
Saint-Michel-sur-Rhône
Saint-Nizier-de-Fornas
Saint-Nizier-sous-Charlieu
Saint-Paul-de-Vézelin
Saint-Paul-d'Uzore
Saint-Paul-en-Cornillon
Saint-Paul-en-Jarez
Saint-Pierre-de-Bœuf
Saint-Pierre-la-Noaille
Saint-Polgues
Saint-Priest-en-Jarez
Saint-Priest-la-Prugne
Saint-Priest-la-Roche
Saint-Priest-la-Vêtre
Saint-Régis-du-Coin
Saint-Rirand
Saint-Romain-d'Urfé
Saint-Romain-en-Jarez
Saint-Romain-la-Motte
Saint-Romain-le-Puy
Saint-Romain-les-Atheux
Saint-Sauveur-en-Rue
Saint-Sixte
Saint-Symphorien-de-Lay
Saint-Thomas-la-Garde
Saint-Thurin
Saint-Victor-sur-Rhins
Saint-Vincent-de-Boisset
Salt-en-Donzy
Salvizinet
Sauvain
Sevelinges
Soleymieux
Souternon
Sury-le-Comtal
La Talaudière
La Terrasse-sur-Dorlay
Thélis-la-Combe
La Tour-en-Jarez
La Tourette
Trelins
La Tuilière
Urbise
Usson-en-Forez
Valeille
Valfleury
La Valla-en-Gier
La Valla-sur-Rochefort
Veauche
Veauchette
Vendranges
Véranne
Verrières-en-Forez
La Versanne
Villemontais
Villers
Viricelles
Virigneux
Vivans
Vougy
Articles to be expanded from July 2014
Geography articles needing translation from Français WorldHeritage
Articles containing Arpitan-language text
Articles needing additional references from August 2012
Communes of Loire (department)
Prefectures in France
Ontario, Quebec City, Quebec, Ottawa, Aboriginal peoples in Canada
Loire (department)
Departments of France, Rhône-Alpes, France, Saint-Étienne, Regions of France
France, Paris, Germany, Italy, Marseille
Algeria, Egypt, Libya, Sudan, Morocco
A72 autoroute
Saint-Étienne, Andrézieux-Bouthéon, France, A89 autoroute, Balbigny
France, France national football team, Brazil national football team, Croatia national football team, Netherlands national football team
Lyon, Grenoble, Saint-Étienne, France, Valence, Drôme
Société de Transports de l'Agglomération Stéphanoise
Saint-Étienne, Saint-Priest-en-Jarez, France, Trolleybus, Firminy
École nationale d'ingénieurs de Saint-Etienne
Saint-Etienne, Arts et Métiers ParisTech, Centrale Graduate School, Grenoble Institute of Technology, École Normale Supérieure

redpajama_set_name: RedPajamaCommonCrawl


Just made the simplest UAS in the back of my de-rimmed Nanocube 28. I read that chaeto would just wash away in the back overflow chamber so I decided and think it is a better idea to put a UAS. I ruffed up the screen and am using a 5 watt led grow light. I am getting patches of dark green. The photos are of 2 weeks growth. When should I scrape some off?
Nice. Nothing better than a super simple DIY that fits and works good.
So after seeing others use higher 12 watts + led grow lights I decided to buy one and try it out.
It says it is 24w but in the details it is listed as 15 watts. I have run it for about a week at pretty much 24 hours on and it has burned the grow mesh algae in the center. It was about 8 inches away but it has very focused lenses. I ended up putting my 5 watt tiny led grow light back in as it seemed to do much better and can run 24 hours.
I also had the idea of putting electrical tape over some of the lenses of the 15 watt leds to lower the light output.
Also, my tank is growing a lot of detritus since last cleaning about a week ago. The tank also smells like fish/algae. I run lots of sea chem matrix, carbon, and puregen. This is my 3rd reef tank and have never had the ones before smelly. Is it a by product of growing so much algae in the water? Why would this be happening.
You can try sanding down the lenses of the LED's to make them less focused.
Any algae/fish smell is usually from an area that was growing algae up near the surface, then the water level dropped, leaving that algae to partially dry.


text:
Ледникът Нинис () е долинен ледник с дължина около 100 km и ширина до 70 km, разположен в Източна Антарктида, на Брега Джордж V, на Земя Виктория. Води началото си от Антарктическото плато на височина около 700 m и "тече" на север-североизток в широка долина. "Влива" се чрез дълъг около 40 km ледников език в море д'Юрвил, част от Индоокеанския сектор на Южния океан, в западната част на залива Бъкли. В западната му част е "бетониран" остров Диксън.

Ледника е открит през декември 1912 г. от видния австралийски антарктически изследовател Дъглас Моусън, ръководител на Австралийската антарктическа експедиция (1911 – 14) и е наименуван от него в чест на английския лейтенант Белгрейв Нинис (1887 – 1912), загинал трагично на 14 декември 1912 г. като прапада в дълбока пункнатина наледника, по време на похода на групата на изток от базата на експедицията.

Източници

География на Антарктида
Ледници в Антарктика

redpajama_set_name: RedPajamaWikipedia


In 2017 the College launched the Engaged Pluralism initiative to perform a structured assessment of diversity, equity, and inclusion efforts on campus. There are student, faculty, and staff working groups covering topics across the college and community.
The EPI is an evolving community initiative to reimagine what it means to live, work, and learn together. In partnership with the Mellon Foundation, Vassar College has embarked on a dynamic & responsive process to cultivate an environment where all members of our community can belong and thrive. We welcome participation from all members of the community.
While the EPI initiative is on-going, In Fall 2017 EPI engaged consultants from Rankin & Associates to conduct focus groups with employees. The results of these conversations will be reported on in the spring.
The Committee on Inclusion and Excellence makes an annual report available on the EPI website and shares the results via campus forums. CIE's reports were instrumental in forming the EPI initiative and have shaped how the College has structured our diversity, inclusion, and equity work.
Progress is shared via the EPI website, through working groups, and via regular public forums.


This week, its part 2 of "Rock of Ages," where we find out who Luthor has recruited for his new Injustice Gang, Martian Manhunter discovers what its like to be crazy, and Batman recruits some extra help.
After taking monthly looks at the Grant Morrison Era of the JLA, we kick things in to high gear by going weekly. And what better time to start than with the 1st part of the classic Rock of Ages story?
Here is a little bit of an off-beat episode that doesnt really have anything to do with comics, movies or TV. Instead, we check out some fun from the radio. Plus, an important announcement about the future of the show.