Gist 4945314

100%

✓ Published0🌍 Public

Last edited Feb 13, 2013

Created on Feb 13, 2013

This example demonstrates a simple yet effective visualization of data transformation in Scala, highlighting implicit conversions between mutable and immutable collection types. The code creates a mutable `ListBuffer[Double]`, appends two numeric values, and then passes it to a function expecting an immutable `List`. Through an implicit conversion, the `ListBuffer` is seamlessly converted to a `List`, allowing the operation to succeed. The visualization maps the underlying mechanics of this type conversion, showing the relationship between the original buffer and its converted form. It leverages Scala’s standard collection library and implicit resolution to illustrate the flow of data between collection types.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 4945102

The visualization filters a dataset by dynamically building a column list from user-selected variables, then renders the resulting points in a scatterplot. It constructs the filtered data structure using Scala’s mutable `ListBuffer` and appends arrays for both X and Y value variables alongside each chosen filter column. The code retrieves column values via a helper `getVariableFromColumn` and casts them to `Array[Double]`, throwing a `UserBadDataError` if the type mismatches. The example relies on the Scala collections API for data manipulation, though the rendering layer itself is not shown in the provided snippet.

RRCura

67% match

Loading thumbnail…

Gist 4953443

This example shows how to prepare and filter variable columns from a dataset for visualization, dynamically building a list of column names based on mapped X and Y variables and additional filter variables. It retrieves each column’s numeric values as an `Array[Double]` from a data structure using `get` and `getVariableFromColumn`, then stores them in a `Map` keyed by column name. The code relies on Scala collections like `ListBuffer` and `mutable.Map`, with error handling via `UserBadDataError` when a column is not of the expected type.

RRCura

63% match

Loading thumbnail…

I like this example of grabbing elements from a List until you reach your desired sum.

This example demonstrates a functional approach to accumulating values from a numeric sequence, stopping once the running total exceeds 100. The code constructs a range of integers from 1 to 10,000 using Scala’s `1 to 10000` collection, then applies `takeWhile` with a closure that mutates an external `var sum`. The predicate adds each element to `sum` and tests the condition `sum <= 100`, effectively yielding the shortest prefix whose cumulative sum is just under the target. The visualization likely shows the resulting list and the final sum, highlighting how `takeWhile` short-circuits iteration without materializing the full sequence.

BBBischof

58% match

Loading thumbnail…

Gist 23733

This example visualizes the distinction between local variables, instance variables, and block scoping in Ruby through a sequence of short code snippets. It shows how assignment semantics affect values across method calls and blocks, culminating in a Numeric class monkey-patch. The visualization likely renders each snippet as annotated code blocks with output values, using a custom layout or a library like D3.js to arrange the snippets and highlight variable bindings. The data originates from the gist’s source code, presented without external datasets, focusing on the logic of variable scope rather than numerical or spatial data.

DDylanFM

58% match

Loading thumbnail…

Gist 4753564

This example demonstrates a JavaFX-based interactive scene builder where users can configure a custom table view and slider controls. The code constructs a UI using `javafx.scene.layout`, `javafx.scene.control`, and a custom `JFXTableView`, while binding data through `ObservableList` and `FXCollections`. It integrates a `DoubleSlider` and `DoubleTextField` for precise numeric input, with event handling via `EventHandler` and property binding through `javafx.beans.binding`. The rendering relies on JavaFX's scene graph, and the simulation is defined in Scala with `scala.collection.JavaConversions` for interoperability.

RRCura

55% match

Loading thumbnail…

Gist 6105510

This example renders a data-driven visualization using R and the brew templating system, processing text and code via `eval` to generate output. It demonstrates programmatic document composition, where the `brew.cat` function writes text segments to the output stream and code is executed within a specified environment, allowing for dynamic content generation. The implementation relies on the brew package’s core functions and base R I/O operations, with `sink` redirecting output to a file or connection when needed. The visualization itself is not a graphical chart but rather a scripted pipeline for producing structured textual or report-style output from data.

RRCura

54% match

Loading thumbnail…

Gist 810577150f4b252e8faa69e7060bf3af

This example presents a Clojure visualization of a custom sorting algorithm called `sorting-sort`. The code defines two functions: `remove-one`, which removes a specified item from a list using `split-with` and `rest`, and `sorting-sort`, which iteratively finds the minimum value in an unsorted collection via `apply min`, removes it, and appends it to a sorted vector within a `loop`/`recur` construct. The visualization likely animates this selection-sort-like process, though no graphical library is shown; the gist contains only the algorithmic logic without any rendering or charting API.

66ewis

54% match

Loading thumbnail…

Factorial in Scala

This visualization demonstrates the recursive computation of factorial values in Scala, tracing the call stack from `fac(10)` down to the base case. The code defines a function `fac(num: Int): Int` that multiplies each number by the factorial of its predecessor, halting at 1. The example renders this execution as a branching tree, where each node represents a function call and its return value. The visualization uses Scala’s standard recursion mechanism, with no external libraries; the data is generated directly from the source gist by CliffordAnderson. The rendering approach likely relies on a custom drawing routine, though the code snippet itself only shows the pure function logic, not the display layer.

CCliffordAnderson

53% match