Azure function HTTP trigger for Mandelbrot calculation

100%

Azure function HTTP trigger for Mandelbrot calculation

✓ Published0🌍 Public

Last edited May 9, 2017

Created on May 9, 2017

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.

AI-generated description

Similar vizzes

Loading thumbnail…

Mandelbrot calculation in Azure Function with Query and Blob binding

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.

HHugoberry

81% 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

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

79% 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

75% 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

75% match

Loading thumbnail…

Playing with Azure Functions

This example visualizes how three Azure Functions HTTP triggers enqueue messages to a shared storage queue, showing the sequential flow from request to queue insertion. The code uses the `ICollector<string>` interface to add messages named "Larry", "Moe", and "Curly" to an Azure Storage queue, with each function call triggering the enqueue operation. The visualization highlights the request–response cycle via the `HttpRequestMessage` and `HttpResponseMessage` objects, while `TraceWriter` logs the incoming URI. It demonstrates the serverless event-driven pattern where HTTP calls produce queue entries, though the rendering itself is not shown in the provided code.

HHugoberry

63% 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

61% 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

61% match