skip to main | skip to sidebar

F# News

Putting the fun in functional programming since 2005!

Friday, 10 December 2010

Most popular F# samples

Here's a short-list of our most popular blog posts that describe example F# programs:

  • Lorenz attractor.
  • Sieve of Eratosthenes.
  • Visualizing a complete graph.
  • Parametric plots.
  • Dragon curve.
  • Bookworm challenge.
  • Red-black trees.
  • Anagrams.
  • Mini hash table.
  • Symbolic manipulation.
  • Pythagoras tree.
  • Morris sequences.
  • Happy numbers.
  • Java vs F#.
  • F# vs Unmanaged C++ for parallel numerics.
  • John Conway's Game of Life.
  • Evolution: the weasel program.
  • Foreign Function Interface (FFI).
Posted by Jon Harrop at 13:10
Labels: article, blog post, example, popular, sample

1 comments:

Art said...

It'll be interesting to see when, maybe in 2011, the interest changes to parallel.

10 December 2010 15:50:00 GMT

Post a Comment

Newer Post Older Post Home
Subscribe to: Post Comments (Atom)

Links

  • Visual F# 2010 for Technical Computing (book)
  • The F#.NET Journal (on-line magazine)
  • F# for Visualization (library)
  • F# for Numerics (library)
  • F# for Scientists (book)
  • OCaml for Scientists (book)
  • The OCaml Journal (on-line magazine)
  • Time-Frequency Analysis (Mathematica library)
  • Signal processing .NET (library)
  • Smoke Vector Graphics (OCaml library)
  • F# demos
  • hubFS: THE place for F#

Popular Posts

  • Threading and Windows Forms
    In order to keep a GUI responsive while other computations are being performed, it is essential to combine threading with GUI programming. ...
  • Java vs F#
    Dr Cliff Click of Azul Systems , specialists in manycore JVM systems, recently published a blog post about the performance of Java compared...
  • Windows forms and Threads
    I've been trying to get the vector graphics renderer from Presenta to play nice with the F# interactive mode. I only just discovered the pr...
  • Don't install VS2010 SP1
    The new Service Pack 1 for Visual Studio 2010 is buggy and may cause irreparable corruption: Installing this service pack destabilized one ...
  • F# vs Unmanaged C++ for parallel numerics
    We obtained a surprising performance result when comparing optimized parallel ray tracers written in F# and C++ recently. The following two...
  • Lorenz attractor
    The Lorenz attractor is a fractal derived from the trajectory of a 3-dimensional dynamical system that exhibits chaotic flow. This blog pos...
  • Performance-related features in F# and C#
    Many people expect the performance of F# to be comparable to the performance of C# "because they both compile to the same intermediate lang...
  • F# vs Mathematica: parametric plots
    Another example from Sal Mangano's Mathematica Cookbook (p.520) is an elegant little Mathematica program that uses a crude numerical integra...
  • F# vs Mathematica: an even faster pricer for American options
    The previous post described a performance-critical pricer for American options. Upon reflection, the optimized Mathematica code had introduc...
  • F# vs Mathematica: red-black trees
    Mathematica is an expensive commercial application sold as software for "interactive technical computing". In particular, the product center...

Follow by Email

Related blogs

  • The Flying Frog Blog
    Learning garbage collection theory - I want to learn the theory behind garbage collection. How do i go about it? I am also a dabbler interested in garbage collection (to the point that I wro...
    1 week ago
  • OCaml News
    Easy parallelism in OCaml - Use the following invoke combinator to apply a function to a value in another (forked) process and then block waiting for its result when the () value is ...
    1 week ago

Subscribe

Posts
Atom
Posts
Comments
Atom
Comments

Blog Archive

  • ►  2012 (50)
    • ►  May (35)
      • Parallel programming in functional languages
      • Applications of priority queues
      • Solving Einstein's Riddle
      • Visualizing the Stanford Bunny using WPF
      • How do I sort lexicographically in F#?
      • Convolve two lists
      • How do you evaluate a quotation in F#?
      • Why are tuples semicolon-separated in F#?
      • Project Euler #13 in F#
      • Functional programming and multicores
      • Refactor your union types to simplify common opera...
      • Compute all permutations
      • How do I spawn a WPF UI from F# interactive asynch...
      • How do I pattern match over different union types?...
      • Unification of OOP and FP in Scala and F#
      • F# for Scheme programmers
      • Literature about writing compilers in F#
      • What's wrong with using async for parallel program...
      • Transpose a graph
      • Select elements that appear more than once
      • Exceptions vs the F# option type
      • F# Map vs .NET Dictionary performance
      • Emulating "goto" in F#
      • Lazily merging two sorted sequences
      • Do purely functional data structures get deep copi...
      • What table-like type has the fastest element looku...
      • Does F# have any advantages over C# for mathematic...
      • When should I use the inline keyword in F#?
      • Why should a .NET developer learn F#?
      • Why are functions not recursive by default in F#?
      • When should we choose F# over C#?
      • Why is F#'s type inference so fickle?
      • F# vs C++ performance
      • Efficiency of F# vs C#
      • Getting started with F#
    • ►  April (2)
      • Writing an x86 JIT compiler
      • Skilled pseudo-science and its intersection with t...
    • ►  March (6)
      • Drawing trees with WPF
      • Compiling to CIL
      • Efficient structural serialization
      • Optimizing Black-Scholes in F#
      • Generating resilient HTML
      • Using LLVM from F# under Windows
    • ►  February (6)
      • Writing a CIL disassembler
      • Benefits of F#
      • Vector Graphics Editor
      • Bloom filter
      • The Very Concurrent Garbage Collector
      • Prototyping a mark-sweep garbage collector
    • ►  January (1)
      • Fast Generic Pretty Printing
  • ►  2011 (32)
    • ►  December (2)
    • ►  November (2)
    • ►  October (3)
    • ►  September (2)
    • ►  August (2)
    • ►  July (3)
    • ►  June (2)
    • ►  May (2)
    • ►  April (2)
    • ►  March (3)
    • ►  February (4)
    • ►  January (5)
  • ▼  2010 (74)
    • ▼  December (4)
      • Performance-related features in F# and C#
      • Parsing mathematical expressions using active patt...
      • Most popular F# samples
      • Numerical methods: matrix inversion
    • ►  November (9)
    • ►  October (4)
    • ►  September (4)
    • ►  August (4)
    • ►  July (10)
    • ►  June (4)
    • ►  May (4)
    • ►  April (7)
    • ►  March (5)
    • ►  February (16)
    • ►  January (3)
  • ►  2009 (63)
    • ►  December (7)
    • ►  November (4)
    • ►  October (5)
    • ►  September (3)
    • ►  August (3)
    • ►  July (6)
    • ►  June (5)
    • ►  May (11)
    • ►  April (3)
    • ►  March (6)
    • ►  February (3)
    • ►  January (7)
  • ►  2008 (61)
    • ►  December (4)
    • ►  November (9)
    • ►  October (3)
    • ►  September (6)
    • ►  August (4)
    • ►  July (5)
    • ►  June (4)
    • ►  May (10)
    • ►  April (3)
    • ►  March (5)
    • ►  February (5)
    • ►  January (3)
  • ►  2007 (55)
    • ►  December (7)
    • ►  November (3)
    • ►  October (3)
    • ►  September (3)
    • ►  August (5)
    • ►  July (4)
    • ►  June (3)
    • ►  May (13)
    • ►  April (6)
    • ►  March (3)
    • ►  February (4)
    • ►  January (1)
  • ►  2006 (12)
    • ►  December (5)
    • ►  November (7)

Labels

  • .net (5)
  • .net 4 (4)
  • .NET Rocks (1)
  • 1.9.2 (1)
  • 2d (1)
  • 3d (3)
  • a* algorithm (2)
  • abstraction (1)
  • active patterns (3)
  • adaptive subdivision (2)
  • ado.net (1)
  • advantages (1)
  • agent (2)
  • algorithm (1)
  • algorithms (2)
  • all-pairs shortest paths (1)
  • allocation (2)
  • american options (2)
  • anagram (1)
  • application (1)
  • approximation (1)
  • array (4)
  • article (2)
  • articles (7)
  • artificial intelligence (2)
  • artificial life (1)
  • assembler (1)
  • assembly (1)
  • asynchronous (6)
  • asynchronous workflows (6)
  • atom (2)
  • attributes (1)
  • audio (1)
  • augmentations (1)
  • automated (1)
  • automation (1)
  • autostereograms (1)
  • balanced binary tree (1)
  • balanced tree (1)
  • bdd (1)
  • beginner (7)
  • benchmark (8)
  • benefits (1)
  • bessel function (3)
  • best fit (1)
  • beta (1)
  • bezier (1)
  • binary format (1)
  • binary tree (1)
  • bioinformatics (1)
  • biology (2)
  • bitmaps (1)
  • blog post (1)
  • bloom filter (1)
  • boids (1)
  • book (14)
  • book club (1)
  • book worm (1)
  • brainfuck (1)
  • breadth-first search (1)
  • brevity (1)
  • brian mcnamara (1)
  • bug (1)
  • bugs (1)
  • burrows-wheeler transform (1)
  • bwt (1)
  • byron cook (1)
  • bytecode (3)
  • c (1)
  • c# (7)
  • c# 4 (1)
  • c++ (3)
  • cache (2)
  • cache miss (1)
  • cache oblivious (1)
  • calculator (1)
  • case study (1)
  • catenable list (1)
  • cellular automata (1)
  • challenge (1)
  • chart (5)
  • chat (1)
  • cheat sheet (1)
  • chris smith (1)
  • cil (1)
  • class (1)
  • classes (1)
  • classification (1)
  • client (3)
  • clr (2)
  • code generation (1)
  • coherent graphics (1)
  • combinator (5)
  • combinatorial (2)
  • commercial product (1)
  • communication (1)
  • comparison (2)
  • compiler (4)
  • complete graph (1)
  • complex (1)
  • component design guidelines (1)
  • comprehensions (2)
  • computation expression (1)
  • computational geometry (1)
  • computer algebra (1)
  • concentration (1)
  • concurrent (14)
  • concurrent collection (1)
  • concurrent gc (1)
  • concurrent programming (1)
  • ConcurrentBag (1)
  • ConcurrentQueue (1)
  • ConcurrentStack (1)
  • continuation (1)
  • control (2)
  • controls (1)
  • convex hull (1)
  • copy (1)
  • cost (1)
  • countBy (1)
  • ctp (1)
  • currying (3)
  • curve fitting (1)
  • data compression (3)
  • data structure (5)
  • data structures (2)
  • data visualization (3)
  • database (2)
  • deallocate (1)
  • deep (1)
  • demo (9)
  • depth-first search (1)
  • destructor (1)
  • development (3)
  • diagram (1)
  • dictionary (1)
  • diff (1)
  • differential equation (2)
  • dijkstra (1)
  • dimensional consistency (1)
  • directx (9)
  • disassembler (1)
  • distributed (2)
  • distribution (1)
  • divide and conquer (1)
  • dll (1)
  • do (1)
  • don syme (9)
  • dragon curve (1)
  • dynamic programming (2)
  • dynamics (4)
  • e-mail (1)
  • e-world (1)
  • easy (5)
  • edit distance (1)
  • editor (1)
  • educational (1)
  • eigenvalue (2)
  • eigenvector (1)
  • einsteins riddle (1)
  • emergent behaviour (1)
  • entropy (1)
  • enumerable (1)
  • enumerator (1)
  • equality (1)
  • evaluate (1)
  • event (1)
  • evolutionary algorithm (1)
  • example (3)
  • examples (9)
  • execution (1)
  • exhibition (1)
  • Expert F# (4)
  • export (1)
  • expression (1)
  • expressions (1)
  • extrapolation (1)
  • extreme optimization (1)
  • eye candy (1)
  • f# (72)
  • f# 1.9.9.9 (1)
  • f# 2.0 (1)
  • f# book (1)
  • F# for Numerics (13)
  • f# for scientists (16)
  • f# for technical computing (7)
  • f# for visualization (26)
  • f# interactive (1)
  • f# meetup (1)
  • f# release (4)
  • f# team (1)
  • f#.net (49)
  • f#.net journal (22)
  • fast fourier transform (2)
  • fem (1)
  • fft (6)
  • filtering (2)
  • finance (2)
  • finite element (1)
  • flocking (1)
  • floyd-warshall algorithm (1)
  • fluid dynamics (2)
  • force (1)
  • foreign function interface (1)
  • Fortran (1)
  • forum (1)
  • foundations of f# (3)
  • fourier (3)
  • fparsec (1)
  • fractal (1)
  • free (1)
  • free article (2)
  • function (1)
  • function optimization (1)
  • functional (1)
  • functional programming (3)
  • game (3)
  • games (3)
  • games programming (1)
  • gamma function (1)
  • garbage collection (5)
  • Gaussian (1)
  • generic (3)
  • generics (3)
  • geographic information systems (1)
  • gis (1)
  • global optimization (3)
  • google (1)
  • gouraud (1)
  • gradient descent (1)
  • graph (6)
  • graph algorithms (1)
  • graph reduction (1)
  • graph theory (1)
  • graphical (2)
  • graphics (23)
  • growth (1)
  • gui (10)
  • happy numbers (1)
  • hash table (2)
  • hashing (1)
  • haskell (2)
  • heap (2)
  • high performance (8)
  • higher-order function (5)
  • histogram equalization (1)
  • HTML (1)
  • huffman (1)
  • ide (1)
  • idioms (1)
  • ienumerable (1)
  • ienumerator (1)
  • image (2)
  • immutable (2)
  • impure (1)
  • infiniband (1)
  • inline (2)
  • integral (1)
  • interactive (9)
  • interface (1)
  • interoperability (2)
  • interpolation (1)
  • interpreter (2)
  • interview (4)
  • introduction (2)
  • inverse (1)
  • jacobi algorithm (1)
  • james margetson (1)
  • jason olson (1)
  • java (1)
  • jit (3)
  • jobs (5)
  • joe hummel (1)
  • jon harrop (2)
  • jumo fisher (1)
  • jvm (1)
  • k-means clustering (1)
  • key bindings (1)
  • knights tour (1)
  • kurtosis (1)
  • labelled arguments (1)
  • language (1)
  • latency (1)
  • layout (2)
  • lazy list (1)
  • lazy stream (1)
  • least recently used (1)
  • least squares (1)
  • lecture (10)
  • levenshtein (1)
  • lex (3)
  • library (4)
  • lighting (1)
  • linear algebra (5)
  • linq (1)
  • lisp (1)
  • list (1)
  • live migration (1)
  • llvm (1)
  • lock free (1)
  • logic programming (3)
  • london (2)
  • longest common subsequence (1)
  • look and say sequence (1)
  • lorenz attractor (1)
  • Lotka-Volterra equations (1)
  • low latency (2)
  • lru (1)
  • lu decomposition (1)
  • luca bolognese (1)
  • luke hoban (1)
  • lzw (1)
  • machine learning (1)
  • mailbox processor (1)
  • map (1)
  • map reduce (1)
  • mark sweep (1)
  • markdown (1)
  • market share (1)
  • Mathematica (6)
  • matlab (2)
  • matrix (5)
  • matrix inversion (2)
  • maze (1)
  • median (1)
  • member (1)
  • memoization (1)
  • memory leak (1)
  • mersenne twister (1)
  • mesh (1)
  • message loop (2)
  • message passing (3)
  • metaprogramming (5)
  • method (1)
  • method dispatch (1)
  • microsecond (1)
  • microsoft (1)
  • mine sweeper (1)
  • minimization (2)
  • MissingMethodException (1)
  • module (1)
  • molecular dynamics (1)
  • monad (1)
  • monadic (1)
  • monte-carlo (2)
  • morris sequence (1)
  • moving average (2)
  • mpi (1)
  • multiple plots (1)
  • mutable (2)
  • mutation (1)
  • named arguments (1)
  • native code (1)
  • natural selection (1)
  • neighbors (1)
  • network (6)
  • new england (1)
  • non-blocking algorithm (1)
  • Normal distribution (1)
  • numerical (10)
  • numerical integration (3)
  • numerical methods (7)
  • numerics (1)
  • nunit (1)
  • objects (1)
  • observable (1)
  • obstruction free (1)
  • ocaml (3)
  • opengl (1)
  • optimization (11)
  • optimize (1)
  • optional arguments (2)
  • or-pattern (1)
  • pangram (1)
  • parallel (20)
  • parallel for (1)
  • parallel fx (2)
  • parallel programming (3)
  • parallelism (1)
  • parametric plot (1)
  • parametric polymorphism (1)
  • parser (2)
  • parser combinator (1)
  • parsing (5)
  • particle (2)
  • path finding (1)
  • pattern matching (5)
  • pdb (1)
  • pdf (1)
  • performance (34)
  • phil trelford (1)
  • phong (1)
  • physics (1)
  • pickling (1)
  • pinvoke (1)
  • plot (1)
  • podcast (2)
  • poll (1)
  • polygons (1)
  • polymorphism (1)
  • pop3 (1)
  • popular (2)
  • precedence climbing (1)
  • predator-prey dynamics (1)
  • pretty print (2)
  • pricer (2)
  • prime number (1)
  • printf (1)
  • priority queue (2)
  • product (4)
  • profiling (1)
  • programs (1)
  • protein (1)
  • purely functional (4)
  • purely functional data structures (4)
  • puzzle (1)
  • pythagoras tree (1)
  • python (3)
  • qr decomposition (2)
  • queens problem (1)
  • queue (2)
  • quickhull algorithm (1)
  • quicksort (2)
  • random (1)
  • random number (1)
  • randomized (1)
  • rational (1)
  • ray tracer (5)
  • raytracer (1)
  • reactive extensions (1)
  • real-time (6)
  • recommendations (1)
  • recursion (3)
  • recursive descent (1)
  • red-black tree (1)
  • reddit (1)
  • reflection (5)
  • reflector (1)
  • regex (1)
  • regexp (1)
  • regular expression (1)
  • release (14)
  • reliability (1)
  • remote procedure call (1)
  • repl (1)
  • replace (1)
  • resources (1)
  • return (1)
  • reuse (1)
  • review (13)
  • richard morris (1)
  • rigid body (2)
  • roadmap (1)
  • rosetta code (4)
  • round robin (1)
  • route finding (1)
  • rtin (1)
  • run-time type (1)
  • salary (2)
  • sample (1)
  • scalability (3)
  • scatter plot (1)
  • scheme (1)
  • scientific computing (3)
  • scimark (1)
  • scimark2 (2)
  • screencast (1)
  • search (2)
  • searching (1)
  • second edition (1)
  • see and say sequence (1)
  • selection (1)
  • seq (2)
  • sequence (2)
  • sequence expressions (5)
  • serialization (1)
  • series (1)
  • server (6)
  • server gc (1)
  • service pack 1 (1)
  • set (2)
  • set collection (1)
  • shader (1)
  • shallow (1)
  • shared memory (1)
  • shunting yard (1)
  • sieve of eratosthenes (1)
  • silverlight (5)
  • simple (8)
  • simplification (1)
  • simulated annealing (2)
  • simulation (6)
  • sinc (1)
  • singular value decomposition (1)
  • skewness (1)
  • skill (1)
  • skills matter (1)
  • slice (1)
  • slicing (1)
  • slider (1)
  • slides (1)
  • sliding window (2)
  • smtp (1)
  • snippets (1)
  • sockets (1)
  • sort (2)
  • sorting (1)
  • source code (10)
  • sparse linear algebra (1)
  • special offer (2)
  • spectral (1)
  • spectral methods (1)
  • spell checking (1)
  • split (1)
  • sql (2)
  • sql server (1)
  • sql server ce (1)
  • sql server compact edition (1)
  • stack language (1)
  • stanford bunny (1)
  • static linking (1)
  • static type checking (1)
  • static typing (1)
  • stencil buffer (1)
  • stereo (1)
  • streams (1)
  • string (3)
  • strongly-connected components (1)
  • struct (3)
  • structural (1)
  • structure (1)
  • style guide (1)
  • substring (1)
  • successive over relaxation (1)
  • sudoku (3)
  • support (1)
  • survival of the fittest (1)
  • swarming (1)
  • Symbol tables (1)
  • symbolic (1)
  • symbolic differentiation (1)
  • synchronous (1)
  • tail calls (3)
  • tail recursion (2)
  • task parallel library (3)
  • tcp (3)
  • tdd (1)
  • teapot (1)
  • tesselation (1)
  • testing (1)
  • text (1)
  • the code project (1)
  • thread (2)
  • threading (5)
  • throughput (1)
  • thunk (1)
  • tic tac toe (2)
  • tiling (1)
  • tin (1)
  • topological sort (1)
  • tpl (2)
  • training (1)
  • traveling salesman (2)
  • traversal (1)
  • tree (2)
  • treemap (1)
  • trend (1)
  • triangulated irregular network (1)
  • tutorial (11)
  • tutorials (3)
  • twitter (1)
  • type variable (1)
  • typeful programming (1)
  • types (1)
  • typeset (1)
  • units of measure (1)
  • unmanaged code (2)
  • update (1)
  • use (1)
  • user interface (1)
  • using (1)
  • validation (1)
  • value type (1)
  • vcgc (1)
  • vector (2)
  • vector graphics (5)
  • video (10)
  • virtual (1)
  • visual f# 2010 for technical computing (1)
  • visual studio (3)
  • visual studio 2010 (8)
  • visualisation (1)
  • visualization (21)
  • wait free (1)
  • wavelet (2)
  • weasel program (1)
  • web (2)
  • web crawler (2)
  • web programming (1)
  • web service (1)
  • welcome (1)
  • whisp (1)
  • windows (1)
  • windows forms (8)
  • windows presentation foundation (22)
  • word frequency (1)
  • workstation gc (1)
  • wpf (18)
  • x86 (1)
  • xaml (1)
  • xml-rpc (1)
  • xna (5)
  • yacc (1)

About Me

Jon Harrop
Specialist in the use of functional programming for technical computing in industry and academia.
View my complete profile

Total Pageviews

Sparkline