Gist 740340

100%

✓ Published0🌍 Public

Last edited Dec 14, 2010

Created on Dec 14, 2010

This example demonstrates a parallelized aggregate operation that sums the integers from zero to one million using Language-Integrated Query (LINQ). The code uses the `Enumerable.Range` method to generate the data sequence and calls `AsParallel()` to enable parallel execution across multiple threads. The `Aggregate` function then combines each element with an accumulator, applying the addition lambda `(x, y) => x + y` to produce the total. The visualization likely maps the resulting sum or the execution process, though the rendering method is not specified in the provided source code.

AI-generated description

Similar vizzes

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

59% match

Loading thumbnail…

Gist e8e67bab8a73e27d741e5a1d793bb5bd

This example demonstrates how to multiply all numbers within a nested array structure, flattening the multiplication across sub-arrays. The code uses nested `for` loops to iterate through each inner array, updating a running `product` variable. A test case with `[[1,2],[3,4],[5,6,7]]` is provided at the end, showing the expected result of 5040. The visualization highlights the logic of nested iteration and cumulative multiplication, with the data source being the hardcoded test array. No external libraries or rendering APIs are used, as the focus is on the algorithmic pattern in plain JavaScript.

DDocwali777

58% match

Loading thumbnail…

Gist 3745f53a79313afd139b4eb0a4e97bd2

This example visualizes the nested execution of JavaScript closures by tracing function calls and their returned values. It shows how `makeASum(a)` returns an inner function `sum(b)` that captures the outer variable `a`, and how different instances like `sumOne` and `sumTen` preserve distinct contexts. The rendering uses a custom SVG-based trace, likely driven by D3’s `d3.forceSimulation` for layout and `d3.select` for DOM updates, with console logs mapping to animated nodes and edges. The data originates from the inline script’s execution sequence, displaying call stacks and computed sums in real time.

MMistyBlunch

56% match

Loading thumbnail…

linq.js - LINQ for JavaScript ver 2.2.0.2 (Jan. 21th, 2011)

This example demonstrates the linq.js library, a LINQ-to-JavaScript implementation, through a compact source file that defines an `Enumerable` object with a chainable API. The code showcases methods like `Choice`, `Cycle`, `From`, and `Range`, which generate or transform sequences, along with internal enumerator and dispose patterns for lazy iteration. It highlights how functional query operations can be ported from .NET to JavaScript, using constructors, prototype methods, and lambda-style function creation to mimic LINQ’s deferred execution model.

JJn1532

55% match

Loading thumbnail…

Parallel execution with Azure Function PART2

This example shows a serverless Azure Function that computes a single row of a Mandelbrot set and writes it to blob storage, demonstrating parallel execution by partitioning the workload across multiple function invocations. The code uses an `IBinder` to dynamically create a blob output for each batch, with `Generate.LinearSpaced` generating the x-coordinates and LINQ’s `Select` mapping each x-value to a `MandelbrotPoint` at a fixed y-coordinate. Each function run processes one batch and serializes the resulting row as JSON via `JsonConvert.SerializeObject`, saving it as a GUID-named blob in the specified folder. The visualization implicitly relies on the aggregation of these row blobs, though the rendering itself is not shown here.

HHugoberry

54% match

Loading thumbnail…

Gist 0741f09ac75691d8827393a472500145

This example visualizes daily active user counts by processing a hardcoded dataset of user IDs and their activity dates. It first concatenates all user activity date strings into a single delimiter-separated string, then uses an array of dates generated with Moment.js to count occurrences of each date in that combined string via string splitting and array length arithmetic. The result is a plain object mapping each date to its activity count, computed synchronously within a `console.time` block to measure performance. The visualization relies on native JavaScript array methods and Moment.js date formatting, with no external charting or rendering library involved.

AA6Brgeuka

54% match

Loading thumbnail…

Gist 6aa3450d9b856251aaedccbfbb552622

This visualization generates two concentric, spiral-like polylines from tabular data, with each line tracing a sequence of points along a circular path. The first series sweeps through a wide angular range, while the second covers a narrower band, creating a layered, oscillating pattern. The rendering relies on Power Query’s `#table` constructor to build the dataset and a custom `List.Accumulate` function to compute each point’s coordinates based on a category, step count, and angular start/end values. The resulting shape emphasizes the geometric relationship between the two angular intervals, showing how a simple parametric function can produce a visually rhythmic composition.

HHugoberry

54% match

Loading thumbnail…

Gist ee5686347047ba8685a25aaa85169791

This visualization tracks the cumulative frequency of a list of integer adjustments, showing the running total as it evolves through the sequence. It uses D3.js to render a line chart on an SVG canvas, with the x-axis representing the step number and the y-axis the accumulated sum. The data comes from a plain-text file of frequency changes, reminiscent of the Advent of Code challenge. The implementation likely employs `d3.scaleLinear` and `d3.line` to map the data points and draw the path, with axes generated via `d3.axisBottom` and `d3.axisLeft`.

BBBischof

54% match