1 people like it.
Like the snippet!

Generate simple linear equation systems

Generates simple systems of linear equations, suitable for being solved by someone who's just started learning about them. Change the ranges to make them suitable for solving without a calculator.

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33: 
34: 
35: 
36: 
37: 
38: 
39: 
40: 
41: 
42: 
43: 
44: 
45: 
46: 
47: 
48: 
49: 
50: 
51: 
52: 
53: 
54: 
55: 
56: 
57: 
58:

type Variable = char * int // symbol * value
type Term = int * Variable list // coefficient * variables
type Equation = Term list * int * int // terms * constant-term * result

let genEquationSet numVars =
    let rng = new System.Random()
    let vars : Variable[] =
        "acdefghijkmnpqrtuvwxy".ToCharArray() // avoid letters that could be confused with numbers
        |> Array.sortBy(fun _ -> rng.Next())
        |> Seq.take numVars
        |> Seq.map (fun ch -> ch, rng.Next(-25, 26)) // range of values that variables may take
        |> Seq.toArray
    let rec triangular freeVars accum =
        match freeVars with
        | 0 -> accum
        | _ ->
            let constTerm =
                if rng.NextDouble() > 0.3 then rng.Next(-99,100) // constant term range of values
                else 0
            let simpleTerms, simpleResult =
                let coeffs =
                    Seq.initInfinite (fun _ -> rng.Next(-15,16)) // range of values for term coefficients
                    |> Seq.filter ((<>) 0)
                    |> Seq.take freeVars
                    |> Seq.toArray
                let terms : Term list =
                    vars
                    |> Seq.take freeVars
                    |> Seq.mapi (fun i (ch,value) -> coeffs.[i], [ch,value])
                    |> Seq.toList
                let result =
                    terms |> Seq.fold (fun state (cf,[_,v]) -> state + cf*v) 0
                terms, result
            let e : Equation = simpleTerms, constTerm, simpleResult+constTerm
            triangular (freeVars-1) (e::accum)
            |> List.rev
    let stringifyEqn (e : Equation) =
        let terms, constterm, result = e
        let sb = System.Text.StringBuilder()
        for (cf,vars) in terms do
            if cf >= 0 then sb.Append '+' |> ignore
            sb.Append cf |> ignore
            for (sym,_) in vars do
                sb.Append sym |> ignore
        if constterm > 0 then sb.AppendFormat("+{0}",constterm) |> ignore
        elif constterm < 0 then sb.Append constterm |> ignore
        sb.AppendFormat("={0}",result) |> ignore
        sb.ToString().TrimStart('+')
    triangular vars.Length []
    |> List.map stringifyEqn

// usage:
// > genEquationSet 3;;
// val it : string list = ["14u-12i+2q+59=149"; "11u-1i=124"; "10u=120"]
// > genEquationSet 2;;
// val it : string list = ["-3j-82=-97"; "-12j+7y-74=-295"]
// > genEquationSet 4;;
// val it : string list = ["10h+81=161"; "15h-15w+7=382"; "10h-14w+6g-28=356"; "-6h+9w+4g-13f+97=18"]

Multiple items
val char : value:'T -> char (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.char

--------------------
type char = System.Char

Full name: Microsoft.FSharp.Core.char

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

--------------------
type int = int32

Full name: Microsoft.FSharp.Core.int

--------------------
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

type Term = int * Variable list

Full name: Script.Term

type Variable = char * int

Full name: Script.Variable

type 'T list = List<'T>

Full name: Microsoft.FSharp.Collections.list<_>

type Equation = Term list * int * int

Full name: Script.Equation

val genEquationSet : numVars:int -> string list

Full name: Script.genEquationSet

val numVars : int

val rng : System.Random

namespace System

Multiple items
type Random =
  new : unit -> Random + 1 overload
  member Next : unit -> int + 2 overloads
  member NextBytes : buffer:byte[] -> unit
  member NextDouble : unit -> float

Full name: System.Random

--------------------
System.Random() : unit
System.Random(Seed: int) : unit

val vars : Variable []

module Array

from Microsoft.FSharp.Collections

val sortBy : projection:('T -> 'Key) -> array:'T [] -> 'T [] (requires comparison)

Full name: Microsoft.FSharp.Collections.Array.sortBy

System.Random.Next() : int
System.Random.Next(maxValue: int) : int
System.Random.Next(minValue: int, maxValue: int) : int

module Seq

from Microsoft.FSharp.Collections

val take : count:int -> source:seq<'T> -> seq<'T>

Full name: Microsoft.FSharp.Collections.Seq.take

val map : mapping:('T -> 'U) -> source:seq<'T> -> seq<'U>

Full name: Microsoft.FSharp.Collections.Seq.map

val ch : char

val toArray : source:seq<'T> -> 'T []

Full name: Microsoft.FSharp.Collections.Seq.toArray

val triangular : (int -> Equation list -> Equation list)

val freeVars : int

val accum : Equation list

val constTerm : int

System.Random.NextDouble() : float

val simpleTerms : Term list

val simpleResult : int

val coeffs : int []

val initInfinite : initializer:(int -> 'T) -> seq<'T>

Full name: Microsoft.FSharp.Collections.Seq.initInfinite

val filter : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>

Full name: Microsoft.FSharp.Collections.Seq.filter

val terms : Term list

val mapi : mapping:(int -> 'T -> 'U) -> source:seq<'T> -> seq<'U>

Full name: Microsoft.FSharp.Collections.Seq.mapi

val i : int

val value : int

val toList : source:seq<'T> -> 'T list

Full name: Microsoft.FSharp.Collections.Seq.toList

val result : int

val fold : folder:('State -> 'T -> 'State) -> state:'State -> source:seq<'T> -> 'State

Full name: Microsoft.FSharp.Collections.Seq.fold

val state : int

val cf : int

val v : int

val e : Equation

Multiple items
module List

from Microsoft.FSharp.Collections

--------------------
type List<'T> =
  | ( [] )
  | ( :: ) of Head: 'T * Tail: 'T list
  interface IEnumerable
  interface IEnumerable<'T>
  member Head : 'T
  member IsEmpty : bool
  member Item : index:int -> 'T with get
  member Length : int
  member Tail : 'T list
  static member Cons : head:'T * tail:'T list -> 'T list
  static member Empty : 'T list

Full name: Microsoft.FSharp.Collections.List<_>

val rev : list:'T list -> 'T list

Full name: Microsoft.FSharp.Collections.List.rev

val stringifyEqn : (Equation -> string)

val constterm : int

val sb : System.Text.StringBuilder

namespace System.Text

Multiple items
type StringBuilder =
  new : unit -> StringBuilder + 5 overloads
  member Append : value:string -> StringBuilder + 18 overloads
  member AppendFormat : format:string * arg0:obj -> StringBuilder + 4 overloads
  member AppendLine : unit -> StringBuilder + 1 overload
  member Capacity : int with get, set
  member Chars : int -> char with get, set
  member Clear : unit -> StringBuilder
  member CopyTo : sourceIndex:int * destination:char[] * destinationIndex:int * count:int -> unit
  member EnsureCapacity : capacity:int -> int
  member Equals : sb:StringBuilder -> bool
  ...

Full name: System.Text.StringBuilder

--------------------
System.Text.StringBuilder() : unit
System.Text.StringBuilder(capacity: int) : unit
System.Text.StringBuilder(value: string) : unit
System.Text.StringBuilder(value: string, capacity: int) : unit
System.Text.StringBuilder(capacity: int, maxCapacity: int) : unit
System.Text.StringBuilder(value: string, startIndex: int, length: int, capacity: int) : unit

val vars : Variable list

System.Text.StringBuilder.Append(value: char []) : System.Text.StringBuilder
   (+0 other overloads)
System.Text.StringBuilder.Append(value: obj) : System.Text.StringBuilder
   (+0 other overloads)
System.Text.StringBuilder.Append(value: uint64) : System.Text.StringBuilder
   (+0 other overloads)
System.Text.StringBuilder.Append(value: uint32) : System.Text.StringBuilder
   (+0 other overloads)
System.Text.StringBuilder.Append(value: uint16) : System.Text.StringBuilder
   (+0 other overloads)
System.Text.StringBuilder.Append(value: decimal) : System.Text.StringBuilder
   (+0 other overloads)
System.Text.StringBuilder.Append(value: float) : System.Text.StringBuilder
   (+0 other overloads)
System.Text.StringBuilder.Append(value: float32) : System.Text.StringBuilder
   (+0 other overloads)
System.Text.StringBuilder.Append(value: int64) : System.Text.StringBuilder
   (+0 other overloads)
System.Text.StringBuilder.Append(value: int) : System.Text.StringBuilder
   (+0 other overloads)

val ignore : value:'T -> unit

Full name: Microsoft.FSharp.Core.Operators.ignore

val sym : char

System.Text.StringBuilder.AppendFormat(format: string, [<System.ParamArray>] args: obj []) : System.Text.StringBuilder
System.Text.StringBuilder.AppendFormat(format: string, arg0: obj) : System.Text.StringBuilder
System.Text.StringBuilder.AppendFormat(provider: System.IFormatProvider, format: string, [<System.ParamArray>] args: obj []) : System.Text.StringBuilder
System.Text.StringBuilder.AppendFormat(format: string, arg0: obj, arg1: obj) : System.Text.StringBuilder
System.Text.StringBuilder.AppendFormat(format: string, arg0: obj, arg1: obj, arg2: obj) : System.Text.StringBuilder

System.Text.StringBuilder.ToString() : string
System.Text.StringBuilder.ToString(startIndex: int, length: int) : string

property System.Array.Length: int

val map : mapping:('T -> 'U) -> list:'T list -> 'U list

Full name: Microsoft.FSharp.Collections.List.map

Raw view Test code New version

More information

Link:	http://fssnip.net/lM
Posted:	10 years ago
Author:	Anonymous
Tags:	education , learning , mathematics