1 people like it.

# 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 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
System.Text.StringBuilder.Append(value: obj) : System.Text.StringBuilder
System.Text.StringBuilder.Append(value: uint64) : System.Text.StringBuilder
System.Text.StringBuilder.Append(value: uint32) : System.Text.StringBuilder
System.Text.StringBuilder.Append(value: uint16) : System.Text.StringBuilder
System.Text.StringBuilder.Append(value: decimal) : System.Text.StringBuilder
System.Text.StringBuilder.Append(value: float) : System.Text.StringBuilder
System.Text.StringBuilder.Append(value: float32) : System.Text.StringBuilder
System.Text.StringBuilder.Append(value: int64) : System.Text.StringBuilder
System.Text.StringBuilder.Append(value: int) : System.Text.StringBuilder
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