Skip to main content
SimilarExport ZIP
100%

Mandelbrot calculation in Azure Function with Query and Blob binding

✓ Published0🌍 Public
HHugoberry
Last edited May 9, 2017
Created on May 9, 2017

This example shows a serverless Azure Function that computes the Mandelbrot set for a grid of complex coordinates and writes the resulting iteration counts to a blob. It reads a JSON trigger input containing the image bounds and resolution, then uses the .NET `System.Numerics.Complex` type to iterate the Mandelbrot recurrence for each point, counting up to 1000 iterations until the magnitude exceeds 4. The function builds an array of complex coordinates from the requested resolution and range, calculates the Mandelbrot value for each, and serializes the results as JSON to the output blob binding. The visualization itself is not rendered here; instead, the code produces raw numeric data for later plotting.

AI-generated description

Similar vizzes

Loading thumbnail…

Azure function HTTP trigger for Mandelbrot calculation

This example demonstrates a serverless Azure Function that calculates Mandelbrot set coordinates in parallel by partitioning the rendering job into discrete units. The HTTP-triggered PowerShell script (`AzzureFunctionHTTP.ps1`) accepts a JSON payload via `$req`, parses it with `ConvertFrom-Json`, and splits the requested resolution into 1000 sub-jobs, each assigned a unique step interval along the x-axis. Each sub-job is packaged with its folder, request parameters, and computed step value, then serialized with `ConvertTo-Json` and written to an output queue (`$outputQueueItem`). The code relies on the Azure Functions runtime and standard PowerShell cmdlets (`Out-File`, `[guid]::newguid()`) for blob folder naming and output handling, without external visualization libraries.

HHugoberry
81% match
Loading thumbnail…

Fetching the Mandelbrot Set from the execution of Azure Functions

This example visualizes the Mandelbrot set by fetching precomputed JSON blobs from an Azure Storage container. The Power Query code uses the `AzureStorage.Blobs` API to connect to the storage account, filters the blobs by a folder named "ZZZ", and retrieves their content. Each blob is parsed with `Json.Document` to extract the set’s data, which is then combined into a single table via `Table.FromRecords` and `List.Combine`. The visualization shows how distributed execution of Azure Functions can fragment and reassemble complex mathematical data, presenting the classic fractal shape through a straightforward data-fetching pipeline.

HHugoberry
81% match
Loading thumbnail…

Schedule an Mandelbrot Set calculation in Azure Functions

This example shows a Power Query script that calculates a Mandelbrot set by sending a POST request to an Azure Functions HTTP endpoint. The code defines a URI with a query parameter for the authentication code, constructs a JSON body specifying the coordinate bounds (XMin, YMin, XMax, YMax) and a resolution of 1000, then uses `Web.Contents` to post the request with a JSON content type header. The response, parsed via `Json.Document`, contains the resulting set. The visualization demonstrates how to offload compute-intensive fractal generation to a serverless function and retrieve the outcome as structured data.

HHugoberry
80% 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
79% match
Loading thumbnail…

Parallel execution with Azure Functions PART1

This example demonstrates a serverless approach to computing a Mandelbrot set in parallel using Azure Functions. It shows how an HTTP-triggered function decomposes a rendering task into discrete horizontal strips, each queued as a separate work item via `IAsyncCollector<MandelbrotBatch>`. The code uses `HttpRequestMessage` to receive a `MandelbrotSetRequest`, generates evenly spaced y-coordinates with `Generate.LinearSpaced`, and enqueues each batch with a unique output folder GUID. The function returns the folder ID to the caller, while the queue orchestrates distributed processing of each row, leveraging Azure Queues for scalable parallelism.

HHugoberry
74% match
Loading thumbnail…

Generating Mandelbrot set in Power Query

This example renders the Mandelbrot set entirely within Power Query by generating a 1080-point sequence with `List.Generate`, mapping each point to the complex plane, and iterating the classic Mandelbrot formula to compute escape values. It visualizes the resulting 2D grid of iteration counts as a static bitmap, relying on Power Query’s built-in table and chart capabilities rather than external libraries. The code exposes a compact, functional approach to fractal generation, directly showing how iteration-based math translates into a visual image without specialized graphics APIs.

HHugoberry
70% match
Loading thumbnail…

Adding a delay between request for computing a Mandelbrot Set calculation and a fetch the results from blob storage

This example demonstrates how to introduce a deliberate ten-second pause between scheduling a Mandelbrot Set calculation and retrieving the result from blob storage. It uses Power Query’s `Function.InvokeAfter` to delay the execution of `MandelbrotBlobFetch`, which asynchronously fetches the computed image from a blob container. The `MandelbrotSchedule` function determines the target folder path, while the delay ensures the computation has finished before the data is pulled. This pattern is useful for coordinating long-running background tasks with subsequent data retrieval in a data-refresh pipeline.

HHugoberry
66% match
Loading thumbnail…

Computing Mandelbrot Set for limit 1K

This visualization renders the Mandelbrot set for a maximum iteration limit of 1,000, using the `System.Numerics.Complex` type from C#. It shows the complex plane’s escape-time behavior, where each point is colored by the iteration count returned from a custom `Mandelbrot` function. The code computes the set by iterating `z = z * z + c` while the magnitude stays below 4 and the count is under 1000. The rendering approach is not shown in the snippet, but the computation relies on the `System.Numerics` library, and the source is a gist by Hugoberry, with the plot itself being data-derived from the function’s output.

HHugoberry
63% match