Dieser Artikel wurde maschinell übersetzt.

Testlauf

Kombinationen und Permutationen mit F#

James McCaffrey

Beispielcode herunterladen

Das Verständnis von Kombinationen und Permutationen ist eine grundlegende Fähigkeit beim Testen von Software. Im Testlauf-Artikel dieses Monats zeige ich Ihnen, zum Arbeiten mit Tastenkombinationen und Variationen in der neuen Sprache f# geschriebenen Code verwenden.

Eine mathematische Kombination ist eine Teilmenge von k Elementen aus einer Menge von n Elementen, wobei Reihenfolge keine Rolle spielt ausgewählt. Für Ex-ausreichend, wenn n = 5 und k = 2, werden alle Möglichkeiten für zwei Elemente aus fünf Einträge auswählen:

{0,1}, {0,2}, {0,3}, {0,4}, {1,2}, {1,3}, {1,4}, {2,3}, {2,4}, {3,4}

Beachten Sie, dass ich keine Kombination {1,0} aufgeführt, da es identisch {0,1} angesehen wird. Ich haben darüber hinaus die 10 aufgelistet Kombinationen von fünf Elemente ausgewählt, zwei zu einem Zeitpunkt über was lexikografische Reihenfolge aufgerufen wird, in dem die Werte in jeder Kombination Element aufgeführt sind in aufsteigender Reihenfolge.

Eine mathematische Variation ist alle möglichen Rearrangements von n Elementen. Beispielsweise, wenn n = 4, alle möglichen Permutationen lexikografische nacheinander aufgeführt sind:

{0,1,2,3}, {0,1,3,2}, {0,2,1,3}, {0,2,3,1}, {0,3,1,2}, {0,3,2,1}, {1,0,2,3}, {1,0,3,2}, {1,2,0,3}, {1,2,3,0}, {1,3,0,2}, {1,3,2,0}, {2,0,1,3}, {2,0,3,1}, {2,1,0,3}, {2,1,3,0}, {2,3,0,1}, {2,3,1,0}, {3,0,1,2}, {3,0,2,1}, {3,1,0,2}, {3,1,2,0}, {3,2,0,1}, {3,2,1,0}

Beim Arbeiten mit Tastenkombinationen und Permutationen sind zwei wichtige Funktionen, Choose(n,k) und Factorial(n). Sie sind vermutlich vertraut, mit der Factorial(n)-Funktion häufig als n abgekürzt! Die Factorial(n)-Funktion gibt die Anzahl der Permutationen von Reihenfolge n zurück. Beispiele:

4! = 4 * 3 * 2 * 1 = 24.

Die Funktion Choose(n,k) gibt die Gesamtzahl der Kombinationen von k Elementen aus der n Elemente ausgewählt.

Choose(n,k) = n! / (k! * (n-k)!)

Beispiele:

Choose(5,2) = 5! / (2! * (5-2)!) = 5! / (2! * 3!) = 120 / 12 = 10.

Kombinationen und Permutationen sind Teil des Bereichs der Studie normalerweise Mathematik combinatorial oder Combinatorics nur für kurze bezeichnet.

Eine gute Möglichkeit, damit Sie sehen, wo ich im Artikel dieses Monats weisenden bin ist auf dem Screenshot betrachten in Abbildung 1. Ich habe Windows PowerShell verwendet, Host, aber ich meine F#-Demo-Anwendung möglicherweise genauso problemlos verwendet eine Befehlsshell. Mein Startskript von Windows PowerShell, navigieren Sie zu dem Speicherort des Programms CombinatoricsDemo.exe automatisch geändert.

Abbildung 1 Kombinationen und Permutationen mit f#

Hinter den Kulissen bezeichnet die Demo Programm Verweise und ruft in einer F# Code Bibliothek CombinatoricsLib. Die Demo beginnt, indem Sie alle mathematische Kombinationen von fünf Elemente ausgewählt werden drei zu einem Zeitpunkt. Als Nächstes verwendet eine Hilfsmethode, die das letzte Element Kombination {2,3,4}, um ein Array von Zeichenfolgen {Ant, Bat, Cow, Hund, Elk} um {Cow, Hund, Elk} yield angewendet – d. h. die drei Zeichenfolgen aus der ursprünglichen Gruppe, die sich am Indexwerte 2, 3 und 4 sind.

Mein Demo Programm weiterhin durch berechnen und Anzeigen des Wertes der Choose(200,10), die Anzahl der Möglichkeiten, um 10 Elemente aus einer Menge von 200 Elementen auszuwählen, in denen Reihenfolge keine Rolle spielt.

Als Nächstes der Demo-Code berechnet und zeigt den Wert der Factorial(52), der die Gesamtzahl der Möglichkeiten zum Anordnen von Karten in einem standardmäßigen Kartenspiel 52 ist. Beachten Sie, dass das Ergebnis eine sehr, sehr große Zahl ist. Wie ich erläutern werde, verfügt über F#-die Möglichkeit, beliebig große ganze Zahlen zu arbeiten.

Mein Demo-Programm wird beendet, indem alle mathematische Permutationen von n Reihenfolge auflisten = 3.

In den folgenden Abschnitten, beschreibe ich im Detail der F#-Code im Modul "CombinatoricsLib" und den Code in der F#-Demo Programm dargestellt im ausgeführt Abbildung 1. Dabei vergleichen ich die Verwendung der f# mit anderen Sprachen wie Visual Basic und c# für das Arbeiten mit Tastenkombinationen und Variationen.

In dieser Spalte wird davon ausgegangen, dass für Anfänger, fortgeschrittene Erfahrungen mit einer .NET Sprache wie c# und eine sehr grundlegende Kenntnisse im Umgang mit f# vorhanden ist. Auch wenn Sie vollständig neu in f# sind, Sie sollte jedoch in der Lage sein, befolgen meinen Erklärungen zu viel problemlos.

Der CombinatoricsLib f#-Bibliothek

Um meine Combinatorics-Bibliothek zu erstellen, verwendet die Betaversion 2 von Visual Studio 2010, die die Sprache f# und Tools, die erstellt hat. Ich erwarte, dass der F#-Codes ich hier vorstellen zum Arbeiten mit der freigegebenen Version von Visual Studio 2010 ohne wesentlichen Änderungen. Wenn Sie eine frühere Version von Visual Studio verwenden, können Sie die F#-Tools auf der Microsoft F#-Developer Center ( suchen.MSDN.Microsoft.com/FSharp). Zusätzlich zu der Sprache f# Lieferumfang von Visual Studio 2010 Microsoft .NET Framework 4, der meine Bibliothek verwendet.

Ich meine Bibliothek erstellt, durch Starten von Visual Studio 2010 und Auswählen der Datei | neu | Projekt. Das neue Projekt im Dialogfeld ich die F# Library-Vorlage ausgewählt und mit dem Namen Meine Bibliothek CombinatoricsLib. Die allgemeine Struktur des Meine CombinatoricsLib ist in aufgeführt Abbildung 2.

Abbildung 2 Struktur von F#-CombinatoricsLib

module Module1

open System
open System.Numerics // BigInteger class

type Combination(n : int, k : int, a : int[]) = 
  // primary constructor code
  new(n : int, k : int) =
    ...
  member this.IsLast() : bool =
    ... 
  member this.Successor() : Combination =
    ... 
  member this.ApplyTo(a : string[]) : string[] =
    ...
  override this.ToString() : string =
    ... 
  static member Choose(n : int, k : int) : BigInteger =
    ...
  static member Factorial(n : int) : BigInteger =
    ...  
// end type Combination

type Permutation(n : int, a : int[]) =
  // primary constructor code
  new(n : int) =
    ...
  override this.ToString() : string =
    ...
  member this.Successor() : Permutation =
    ... 
  member this.ApplyTo(a : string[]) : string[] =
    ...
  member this.IsLast() : bool =
// end type Permutation

Der Bibliothek Code beginnt mit Visual Studio generierten Code, der meine Bibliothek Module1 benennt. Verwendet diese stattdessen nondescript Standardnamen anstelle des zu aussagekräftigeren zu ändern, so dass die Syntax für den Zugriff auf die Bibliothek weiter unten in diesem Artikel hervorgehoben wird.

Als Nächstes fügte ich zwei F#-öffnen die Anweisungen auf der obersten Ebene System-Namespace und den neuen System.Numerics-Namespace, so dass ich die Klassen in diesen Namespaces zugreifen können, ohne die Klassennamen vollständig qualifizieren. Der <a0>System.Numerics</a0>-Namespace ist Teil der .NET Framework-4 und enthält eine BigInteger-Definition, die mir die Arbeit mit beliebig große ganzzahlige Werte ermöglicht.

Definieren eines Typs in f# unterscheidet sich konzeptionell entsprechende C#-Klasse definiert. Die Definition des Typs hat eine Signatur, die die Eingabeargumente für den Konstruktor des primären Typs enthält:

type Combination(n : int, k : int, a : int[]) =

Diese Signatur bedeutet “ ich verwende einen Typ definieren benannte Kombination, die einen primären Konstruktor verfügt, der Int Argumente n (die Gesamtzahl der Elemente), k (der Teil-Größe) und ein Array von Ganzzahlen ein, der angibt, die Werte einzelner Kombination z. B. {0,1,4} akzeptiert. ”

F#-Typen können optionale sekundäre Konstruktoren, z. B. der in aufgelistet haben Abbildung 2:

new(n : int, k : int) =

Beachten Sie, dass sekundäre Konstruktoren im Gegensatz zu primären Typkonstruktoren das explizite new-Schlüsselwort verwenden. Dieser sekundäre Konstruktor akzeptiert Werte nur für n und k. Mit anderen Programmiersprachen wie c# würden Sie wahrscheinlich einfacheren Konstruktor als primäre-Konstruktor, d. h. vor Konstruktoren definieren, die Argumente annehmen. Aber wie Sie für Typen mit mehreren Konstruktoren in f# ersichtlich ist in der Regel besser, einen Typ in einer Weise erstellen, dass der primäre-Konstruktor mit den meisten Parametern wird. Die Struktur der meine Kombination Typ weiterhin mit drei Memberfunktionen:

member this.IsLast() : bool =
  ... 
member this.Successor() : Combination =
  ... 
member this.ApplyTo(a : string[]) : string[] =
  ...

Das this-Schlüsselwort bindet Membermethoden, die für externe Aufrufcode öffentlich sichtbar sind. IsLast-Funktion gibt true, wenn das zugeordnete Kombinationsfeld-Objekt das letzte Element lexikografische damit, wie z. B. {2,3,4} für n = 5 und k = 3, wie in Abbildung 1.

Die Successor-Funktion gibt das nächste Element der kombinierten lexikografische nacheinander auf das aktuelle Element zurück.

ApplyTo-Funktion akzeptiert ein Array von Zeichenfolgen und gibt ein Array von Zeichenfolgen, das entspricht dem aktuellen Element kombinieren.

Meine nächste Typ Member-Funktion bietet eine Möglichkeit, ein Kombinationsfeld-Element anzuzeigen:

override this.ToString() : string =

Verwenden Sie das Override-Schlüsselwort, um meine benutzerdefinierte ToString-Funktion von der Basismethode ToString zu unterscheiden. Da f# eine .NET Sprache ist, erben alle Objekte aus einem gemeinsamen Basis-Objekt, das eine <a1>ToString</a1>-Methode verfügt. Beachten Sie, dass, obwohl die überschriebene ToString-Funktion öffentlichen Bereich verfügt, ich keine Member-Schlüsselwort verwenden.

Die letzten beiden Memberfunktionen in der kombinierten Typ definieren die Funktionen auswählen und Fakultät:

static member Choose(n : int, k : int) : BigInteger =  ...
static member Factorial(n : int) : BigInteger =  ...

Beide Funktionen sind statisch, d. h., die Funktionen zugeordnet sind und direkt aus dem Kontext des kombinierten-Typ statt einer bestimmten Instanz eines Kombinationsfeld-Objekts aufgerufen. Beide Funktionen Rückgabetyp BigInteger, definiert im Namespace System.Numerics, das standardmäßig in F#-Code direkt sichtbar ist.

Zusätzlich zu einem Typ Kombination definiere ich einen Variation Typ wie in der Auflistung in Abbildung 2.

Die Implementierung von F#-Combinatorics-Bibliothek

Jetzt let’s gehen Sie über die Einzelheiten der Implementierung von CombinatoricsLib-Bibliothek. Der primäre Konstruktor Kombination beginnt:

type Combination(n : int, k : int, a : int[]) = 
  do if n < 0 || k < 0 then failwith 
    "Negative argument in Combination ctor"
  do if n < k then failwith 
    "Subset size k is larger than n in Combination"

Eingabeargument Validierung in einem primären Konstruktor durchführen sollten Sie das-Schlüsselwort Gibt an, der Standardwert ist ein Wert, der in der Regel durch funktionale Sprachen wie z. B. f# angenommen wird, anstatt eine Aktion Interessanterweise verwenden. Das Failwith-Schlüsselwort löst eine Ausnahme aus, die durch Aufrufen von Code abgefangen werden kann.

Richten Sie nun ich die kombinierten Typ privaten Member:

let n : int = n // private
let k : int = k
let data = 
  [| for i = 0 to a.Length-1 do yield a.[i] |]

Das Let-Schlüsselwort wird Werte auf Private Member gebunden. Beachten Sie, dass ich Kleinbuchstaben n und k verwenden können wie die beiden Eingabeparameter und als private Felder. Dies sieht ein wenig umständlich und daher in den meisten Fällen verwendet Großbuchstaben Notation für die Parameter oder die privaten Member.

Kopieren die Werte aus dem Array Eingabeargument eine Felddaten verwendet in den Typ standard f# Ausdrucksweise. Die [|. . |] Trennzeichen geben Sie einen änderbaren Array an. Der sekundäre Kombination-Konstruktor erstellt ein Kombinationsfeld Ausgangsobjekt und als definiert ist:

new(n : int, k : int) = 
  do if n < 0 || k < 0 then failwith 
    "Negative argument in Combination ctor"
  do if n < k then failwith 
    "Subset size k is larger than n in Combination"
  let starters = [| for i in 0..k-1 -> i |] 
  new Combination(n,k,starters)

In f# müssen sekundäre Konstruktoren den primären Konstruktor aufrufen. Damit ich definieren ein Int-Array mit dem Namen Starters mit Werten von 0 bis k-1 und zusammen mit n und k an den primären Konstruktor übergeben. Dieser Mechanismus f# ist deshalb es ratsam, alle primären Konstruktor wie der Konstruktor mit den meisten Parametern definieren.

IsLast-Memberfunktion wird wie folgt definiert:

member this.IsLast() : bool =
  if data.[0] = n-k then true
  else false

In Abbildung 1, beachten Sie, dass nur das letzte Element in einer Liste aller Kombinationen hat Wert n-k in die erste Position des Arrays befindet. F# verwendet keine explicit return-Schlüsselwort wie die meisten Sprachen; implizite Rückgabe ist der letzte Wert in einer Funktion, die in diesem Fall entweder true oder false. Die = token Überprüfungen auf Gleichheit in f# und kein Zuweisungsoperator ist. Die Combination.Successor-Funktion ist:

member this.Successor() : Combination =
  // copy input to temp array
  let temp = [| for i in 0..k-1 -> data.[i] |] 
  // find "x" - right-most index to change 
  let mutable x = k-1 
  while x > 0 && temp.[x] = n - k + x do 
    x <- x - 1
  temp.[x] <- temp.[x] + 1 // increment value at x
  // increment all values to the right of x
  for j = x to k-2 do 
    temp.[j+1] <- temp.[j] + 1
  // use primary ctor
  let result = new Combination(n, k, temp) 
  result

Sie zunächst die Werte des aktuellen Kontexts Kombination Objekt in einer veränderlichen Temp Array kopieren. Danach definiere ich eine Indexvariable mit dem Namen X, und positionieren Sie es am Ende das temporäre Array. Ich muss das änderbare-Schlüsselwort verwenden, so dass ich dieses Indexvariable verringern können, da die meisten Variablen in f# unveränderlich standardmäßig sind. Ich verwende die <-Zuweisungsoperator.

Nachdem ich den Schlüsselindex des aktuellen Objekts Kombination gefunden haben, inkrementieren ich dieses Werts und alle Werte, die rechts neben den Schlüsselindex. Anschließend übergeben Sie temporäre Arrays, das sich jetzt hat den Wert des Elements Kombination Nachfolgervorgänge in der primären Konstruktor und das neu erstellte Objekt zurückzugeben.

Beachten Sie, dass ich nicht null zurückgeben wird beim letzten Element der kombinierten – in f# wird es schlechter Stil dazu betrachtet. Der Code, die ich in diesem Artikel vorstellen verwendet eine Formatvorlage, die nicht sehr f#-Ish. F#-Experten würden wahrscheinlich einen rekursiven Ansatz verwenden, aber da ich vorausgesetzt bin, Sie neu in f# sind, wollte ich meine F#-Code so vertraut wie möglich zu gestalten.

Ein alternativer Ansatz zum Schreiben einer Successor-Funktion besteht darin, die .NET IEnumerable-Schnittstelle implementieren.

ApplyTo-Funktion bietet eine Möglichkeit, eine Kombination-Element einer Gruppe von Zeichenfolgenwerten zuzuordnen:

member this.ApplyTo(a : string[]) : string[] =
  if a.Length <> n then failwith 
    "Invalid array size in ApplyTo()"
  // array of int
  let result = Array.zeroCreate k
  for i = 0 to k-1 do
    // bind to array of string
    result.[i] <- a.[data.[i]]
  result

Wenn in einer Memberfunktion durchführen Eingabeargument überprüft werden, muss ich das-Schlüsselwort verwenden, wie in Konstruktoren Typs erforderlich ist. Die statische erstellt Array.zeroCreate-Methode ein Array von Ganzzahlen initialisiert, um alle 0 Werte wie zu erwarten. Die Funktion ApplyTo ist einfach, da die Größe des Bereichs der Werte in einem mathematischen zusammen mit Teilmenge k (0..k - 1) ist genau die Indizes eines beliebigen .NET Arrays der Größe k.

Die überschriebene ToString-Memberfunktion erstellt einfach eine Zeichenfolge, die das Kontextobjekt Werte bestehen:

override this.ToString() : string =
  let mutable s : string = "^ "
  for i in 0..k-1 do
    s <- s + data.[i].ToString() + " "
  s <- s + "^"
  s

Ich habe mich entschieden, mein kombinierten Elemente mit Begrenzen der ^ (Caretzeichen) Zeichen, die gestartet, wird mit den Buchstaben c, und klicken Sie auf Meine Permutationselemente mit dem Prozentzeichen (%) einzuschränken, welche die beginnt mit p, um Hilfe zu identifizieren, ob eine Zeichenfolge aus Ziffern einer kombinierten Permutation-Objekts darstellt.

Die statische <a0>Choose</a0>-Funktion wird codiert, wie in Abbildung 3. 

Abbildung 3 Choose-Funktion

static member Choose(n : int, k : int) : BigInteger =
  if n < 0 || k < 0 then failwith 
    "Negative argument in Choose()"
  if n < k then failwith 
    "Subset size k is larger than n in Choose()"
  let (delta, iMax) =
    if k < n-k then
      (n-k, k)
    else
      (k, n-k)
  let mutable answer : BigInteger = 
    bigint delta + bigint 1 
  for i = 2 to iMax do
    answer <- (answer * (bigint delta + bigint i )) 
      / bigint i
  answer

Anstelle des Computereinsatzes in Wählen Sie aus der Definition, die weiter oben in diesem Artikel beschriebenen, verwende ich zwei Optimierungen. Ich verwenden Sie zuerst der Tatsache, dass auswählen (n k) = (n, n-k) auswählen. Z. B. Choose(9,6) Choose(9,3) =. Zweitens berechnen ich statt Compute drei separate Fakultäten, von die jede sehr groß sein kann, eine Reihe von partiellen Produkte. Um Int-Werte BigInteger Eingabe explizit zu konvertieren, verwende ich die integrierte f# Bigint-Funktion.

Die Implementierung des Typs Variation ist die Implementierung des Typs Kombination sehr ähnlich. Sie können den Herkunftscode, der complete für das CombinationLib-Bibliothek aus der Microsoft Code Gallery Web-Website unter code.msdn.microsoft.com abrufen.

Verwenden die CombinatoricsLib

In diesem Abschnitt erläutert ich die Funktion aufrufen, die in der CombinatoricsLib-Bibliothek, um die Ausführung im Screenshot in gezeigt zu erstellen Abbildung 1. Zunächst startet Visual Studio 2010 und erstellen ein neues F#-Anwendungsprojekt mit dem Namen CombinatoricsDemo. Die gesamte Anwendung wird in aufgeführt Abbildung 4.

Abbildung 4 Verwenden die CobinatoricsLib

open System
open Module1 // the Combinatorics Lib

try

  printfn "\nBegin combinations and permutations with F# demo\n"
  printfn "All combinations of 5 items 3 at a time in lexicographical order are: \n"
  let mutable c = new Combination(5,3)
  printfn "%A" c // print initial combination

  // objects cannot be null in F# so use an explicit method
  while c.IsLast() = false do 
    c <- c.Successor()
    printfn "%A" c
   
  printf "\nThe last combination applied to array [| \"ant\"; \"bat\"; \"cow\"; \"dog\"; \"elk\" |] is: \n"
  let animals = [| "ant"; "bat"; "cow"; "dog"; "elk" |]
  //let result =  c.ApplyTo(animals)
  let result = animals |> c.ApplyTo
  printfn "%A" result

  printfn "\nThe number of ways to Choose 200 items 10 at a time = Choose(200,10) ="
  let Choose_200_10 = Combination.Choose(200,10).ToString("000,000")
  printfn "%s" Choose_200_10

  printfn "\nThe number of ways to arrange 52 cards = 52! = "
  let Factorial_52 = Combination.Factorial(52).ToString("000,000")
  printfn "%s" Factorial_52

  printfn "\nAll permutations of 3 items in lexicographical order are: \n"
  let mutable p = new Permutation(3)
  printfn "%A" p // print initial permutation
  while p.IsLast() = false do
    p <- p.Successor() 
    printfn "%A" p
      
  printfn "\nEnd demo\n"
  Console.ReadLine() |> ignore

with
  | Failure(errorMsg) -> printfn "Fatal error: %s" errorMsg

// end program

Ich vor dem Schreiben von Code, mit der rechten Maustaste auf den Projektnamen im Fenster Projektmappen-Explorer von Visual Studio geklickt haben, und aus dem Kontextmenü die Option Verweis hinzufügen ausgewählt. Anschließend die Registerkarte Durchsuchen ausgewählt und der Assembly CombinatoricsLib.dll navigiert.

Zunächst den Programmcode Demo die Assemblys System und Module1 geöffnete Anweisungen hinzugefügt. Denken Sie daran, dass der Modulname der CombinatorcsLib Module1 ist. Ich umbrochen alle Programmanweisungen, in einen Try / with-Block aufzuzeichnen und zu behandeln von Ausnahmen. Ich instanziieren Sie ein Kombinationsfeld-Objekt, das mit dem sekundären Konstruktor vornehmen einer anfänglichen mathematische Kombination Objekt c der fünf Elemente, die drei zu einem Zeitpunkt durchgeführt: {0,1,2}. Ich verwende den praktische f# %A Formatbezeichner, der anweist, F#-zum Drucken von meinem Kombination-Objekts abgeleitet werden kann. Ich könnte auch das Format der Zeichenfolge %s verwendet haben.

Als Nächstes verwende ich die f# beimFühren Sie Schleife zu durchlaufen und alle 10 Combination(5,3) Elemente anzuzeigen. Zu diesem Zeitpunkt das kombinierten Objekt c ist das letzte Element, und ich rufen Sie die ApplyTo-Funktion, um diese Kombination auf ein Array von Zeichenfolgen zuordnen.

Beachten Sie, dass ich die Funktionen auswählen und Fakultät aus dem Kontext des Kombinationsfeld-Typ anstelle des C Kombination-Objekts aufrufen. Nach dem Aufruf des Typcode Permutation auf ähnliche Weise, abschließend die Demo-Anwendung für die Benutzereingabe mit der Console.ReadLine-Methode, wobei ich den Rückgabewert in der integrierten ignorieren Objekt pipe anhalten. Behandeln von alle Ausnahmen in der with-Block, indem einfach die Ausnahme Fehlermeldung angezeigt.

Zusätzlich zum Aufrufen einer F#-Bibliothek in f#-Programmen, wie ich soeben gezeigt haben, können Sie ein F#-Bibliothek aus einer beliebigen .NET Framework kompatiblen Sprache aufrufen. Darüber hinaus ermöglicht Visual Studio praktische f# interaktive Fenster verwenden, um ad-hoc-Anrufe zu tätigen, wie in Abbildung 5.

Abbildung 5 Interaktive Verwendung der f#-Bibliothek

In der f# interaktiven Fenster am unteren Rand des Bildschirms hinzufügen ich einen Verweis auf die CombinatoricsLib Assembly, indem Sie eingeben:

#r @"C:\(path)\CombinatoricsLib.dll";;

In diesem Fall # R bedeutet einen Verweis hinzuzufügen und; eine interaktive F#-Anweisung beendet.Jetzt kann ich die Funktionen in der Bibliothek interaktiv aufrufen.Äußerst praktisch!

Meiner Meinung nach sind verschiedene vor- und Nachteile mit f#.Auf der negativen Seite fand ich, dass die Lernkurve für f# erheblich Steilere als erwartet wurde.Schreiben in einem funktionalen Stil war ein großes Paradigmenwechsel für mich.Darüber hinaus hat viel also als andere Sprachen f# mehrere Möglichkeiten zum Codieren eines bestimmten Vorgangs führte ich der Meinung sind uneasy darüber, ob ich geschrieben habe F#-Code auf optimale Weise geschrieben wurde.

Jedoch können in meinem Fall zumindest ich die Vorteile von Lernressourcen f# definitiv überwiegen die Kosten.Wenn mit erfahrenen Programmierern f# kommunizieren, informiert die meisten mich, dass in vielen Fällen, obwohl es tatsächlich mehrere Möglichkeiten gibt, einen Vorgang zu codieren Ansatz wird mehr eine Frage der persönlichen Vorlieben als technische Effizienz ist.Darüber hinaus habe mit F#-Syntax grappling und Codierung Paradigmen (z. B. Standard Unveränderlichkeit) mir was ich das Gefühl Einblick in die Codierung in prozeduralem Sprachen wie c# wurde.

Dr.James McCaffrey  *arbeitet für Volt Information Sciences Inc., wo er technische Schulungen für Softwareentwickler bei Microsoft Redmond, Washington, Campus verwaltet. Er hat an verschiedenen Microsoft-Produkten, einschließlich Internet Explorer und MSN Search gearbeitet. Dr. McCarthy ist Autor von “ .NET Test Automation Recipes ” (Apress, 2006). Er kann unter erreicht werden jammc@microsoft.com.                     *

Unser Dank gilt den folgenden technischen Experten für die Durchsicht dieses Artikels:  Brian McNamara, Paul Newson und Matthew Podwysocki