# Operational reports and developer utilities

Each service is a one-time job with a clear processing scope. Review its example, exact price and checkout terms before paying. Private JSON result access lasts 30 days; save a downloaded copy. There is no recurring commitment.

Use authorized non-sensitive input. A prepared quote is unpaid and a signature alone does not establish settlement. Each service validates its input and calculations before checkout. Input and computation profiles describe the work included in one job, not limits on payments or voluntary contributions. No account access, external action, professional certification or outcome guarantee is implied.

## Cohen Label Agreement Report

USD 19.00 per job.

Compare two human labelers after adjusting observed agreement for their separate marginal frequencies. Same units labeled by exactly two raters; unweighted nominal labels. No universal acceptable-agreement threshold. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [scikit-learn.org](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.cohen_kappa_score.html). No endorsement is implied.

Example input:

```json
{
  "table": [
    [
      20,
      5
    ],
    [
      5,
      20
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/observedAgreement": 0.8,
  "/chanceAgreement": 0.5,
  "/kappa": 0.6
}
```

## Fleiss Panel Agreement Report

USD 19.00 per job.

Calculate fixed-panel nominal agreement from per-item category counts. Equal number of at least two ratings per item; counts cannot identify individual-rater bias. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.statsmodels.org](https://www.statsmodels.org/dev/generated/statsmodels.stats.inter_rater.fleiss_kappa.html). No endorsement is implied.

Example input:

```json
{
  "categoryCounts": [
    [
      3,
      0
    ],
    [
      1,
      2
    ],
    [
      0,
      3
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/observedAgreement": 0.7777777777777778,
  "/chanceAgreement": 0.5061728395061729,
  "/kappa": 0.55
}
```

## Krippendorff Nominal Agreement

USD 19.00 per job.

Build the coincidence matrix and estimate chance-corrected nominal disagreement with variable ratings per unit. Two through128 units, zero through16 labels per unit, at most16 effective categories; null means missing. Exclude units with fewer than two nonmissing ratings and use per-unit coincidence normalization. Nominal distances only; a one-category denominator yields null alpha. No annotation/content judgment. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [repository.upenn.edu](https://repository.upenn.edu/bitstreams/9bb32ddb-0121-4f2d-9c26-a9691fcbdece/download). No endorsement is implied.

Example input:

```json
{
  "units": [
    [
      "A",
      "A"
    ],
    [
      "A",
      "B"
    ],
    [
      "B",
      "B"
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/coincidences": [
    [
      2,
      1
    ],
    [
      1,
      2
    ]
  ],
  "/observedDisagreement": 0.3333333333333333,
  "/expectedDisagreement": 0.6,
  "/alpha": 0.4444444444444444
}
```

## ROC Ranking Evidence Report

USD 19.00 per job.

Compare supplied binary outcome scores through threshold ROC points and pairwise rank AUC. Both classes required; tied scores contribute half a pair. Retrospective evaluation only; no model training or deployment. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [scikit-learn.org](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html). No endorsement is implied.

Example input:

```json
{
  "actual": [
    0,
    0,
    1,
    1
  ],
  "scores": [
    0.1,
    0.4,
    0.35,
    0.8
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/auc": 0.75,
  "/positiveCount": 2,
  "/negativeCount": 2,
  "/concordantPairs": 3
}
```

## Average Precision Evidence Report

USD 19.00 per job.

Summarize precision at increases in recall using supplied labels and ranking scores. Step-weighted AP, not trapezoidal PR area; group tied thresholds. No claims about future prevalence or production performance. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [scikit-learn.org](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.average_precision_score.html). No endorsement is implied.

Example input:

```json
{
  "actual": [
    0,
    0,
    1,
    1
  ],
  "scores": [
    0.1,
    0.4,
    0.35,
    0.8
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/averagePrecision": 0.8333333333333333,
  "/positiveCount": 2
}
```

## Brier Probability Evidence Report

USD 19.00 per job.

Audit probabilistic binary predictions with mean squared probability error and reference skill. Binary mean squared convention without extra scaling; probabilities in[0,1]. Reference skill undefined if reference loss zero. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [scikit-learn.org](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.brier_score_loss.html). No endorsement is implied.

Example input:

```json
{
  "actual": [
    0,
    1
  ],
  "probabilities": [
    0.25,
    0.75
  ],
  "referenceProbability": 0.5
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/brierScore": 0.0625,
  "/referenceBrier": 0.25,
  "/skillScore": 0.75
}
```

## Log Loss Probability Evidence

USD 19.00 per job.

Score supplied probability assignments with mean negative natural log likelihood. Require probabilities strictly between0and1, or disclose exact infinite loss; never silently clip. Distinct proper scoring rule from squared probability error. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [scikit-learn.org](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.log_loss.html). No endorsement is implied.

Example input:

```json
{
  "actual": [
    0,
    1
  ],
  "probabilities": [
    0.25,
    0.75
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/meanLogLoss": 0.2876820724517809,
  "/sampleCount": 2
}
```

## Matthews Classification Evidence

USD 19.00 per job.

Evaluate a caller-supplied binary decision table with a balanced correlation statistic. Counts must represent the same population and threshold; zero denominator means undefined, not evidence of correctness. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [scikit-learn.org](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.matthews_corrcoef.html). No endorsement is implied.

Example input:

```json
{
  "truePositive": 30,
  "trueNegative": 50,
  "falsePositive": 10,
  "falseNegative": 10
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/mcc": 0.5833333333333334,
  "/sensitivity": 0.75,
  "/specificity": 0.8333333333333334
}
```

## Probability Calibration Bin Report

USD 19.00 per job.

Compare average supplied probability with observed positive frequency in explicit fixed bins. ECE is sample-count-weighted absolute bin gap; left-closed/right-open bins except final closed endpoint. Bin-dependent descriptive measure, not a universal guarantee. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [scikit-learn.org](https://scikit-learn.org/stable/modules/calibration.html). No endorsement is implied.

Example input:

```json
{
  "actual": [
    0,
    0,
    1,
    1
  ],
  "probabilities": [
    0.1,
    0.4,
    0.6,
    0.9
  ],
  "binEdges": [
    0,
    0.5,
    1
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/bins/0/count": 2,
  "/bins/0/meanProbability": 0.25,
  "/bins/0/observedRate": 0,
  "/bins/1/meanProbability": 0.75,
  "/bins/1/observedRate": 1,
  "/expectedCalibrationError": 0.25
}
```

## Discounted Ranking Gain Report

USD 19.00 per job.

Compare an ordered result list with an ideal order using logarithmically discounted relevance. Nonnegative caller-supplied relevance, explicit linear gain and log2(position+1). No relevance judgments are inferred from document text. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [scikit-learn.org](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.ndcg_score.html). No endorsement is implied.

Example input:

```json
{
  "orderedRelevance": [
    0,
    1
  ],
  "gain": "linear"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/dcg": 0.6309297535714575,
  "/idealDcg": 1,
  "/ndcg": 0.6309297535714575
}
```

## DFA Execution Trace API

USD 3.00 per job.

Trace each token through a supplied deterministic finite automaton. Explicit token alphabet and total transition table. At most 64 states and 16 alphabet symbols; state IDs start at zero. No regular-expression or source-code execution. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.columbia.edu](https://www.cs.columbia.edu/~aho/cs3261/Lectures/L2-Finite_Automata.html). No endorsement is implied.

Example input:

```json
{
  "alphabet": [
    "0",
    "1"
  ],
  "transitions": [
    [
      0,
      1
    ],
    [
      1,
      0
    ]
  ],
  "start": 0,
  "accepting": [
    0
  ],
  "word": [
    "1",
    "0",
    "1"
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/accepted": true,
  "/trace": [
    0,
    1,
    1,
    0
  ],
  "/finalState": 0
}
```

## Epsilon NFA Execution API

USD 3.00 per job.

Evaluate nondeterministic transitions with cycle-safe epsilon closure. Up to 32 states, 256 edges and 1024 tokens. Null denotes epsilon; no regex execution. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.columbia.edu](https://www.cs.columbia.edu/~aho/cs3261/Lectures/L2-Finite_Automata.html). No endorsement is implied.

Example input:

```json
{
  "states": 3,
  "alphabet": [
    "a"
  ],
  "transitions": [
    {
      "from": 0,
      "symbol": null,
      "to": 1
    },
    {
      "from": 1,
      "symbol": "a",
      "to": 2
    }
  ],
  "start": 0,
  "accepting": [
    2
  ],
  "word": [
    "a"
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/accepted": true,
  "/activeTrace": [
    [
      0,
      1
    ],
    [
      2
    ]
  ]
}
```

## NFA Subset Determinization API

USD 3.00 per job.

Construct reachable deterministic subsets, including an empty sink when required. At most 12 input states and 1024 generated subsets, numbered by alphabet-order breadth-first traversal. Reject expansion beyond this computation profile before checkout. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.columbia.edu](https://www.cs.columbia.edu/~aho/cs3261/Lectures/L2-Finite_Automata.html). No endorsement is implied.

Example input:

```json
{
  "states": 2,
  "alphabet": [
    "a"
  ],
  "transitions": [
    {
      "from": 0,
      "symbol": "a",
      "to": 0
    },
    {
      "from": 0,
      "symbol": "a",
      "to": 1
    }
  ],
  "start": 0,
  "accepting": [
    1
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/subsets": [
    [
      0
    ],
    [
      0,
      1
    ]
  ],
  "/transitions": [
    [
      1
    ],
    [
      1
    ]
  ],
  "/accepting": [
    1
  ]
}
```

## DFA Partition Minimization API

USD 3.00 per job.

Merge language-equivalent reachable DFA states using stable partition refinement. Drop unreachable states and number classes by breadth-first alphabet order. Explicit token alphabet and total transition table. At most 64 states and 16 alphabet symbols; state IDs start at zero. No regular-expression or source-code execution. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.columbia.edu](https://www.cs.columbia.edu/~aho/cs3261/Lectures/L2-Finite_Automata.html). No endorsement is implied.

Example input:

```json
{
  "alphabet": [
    "a",
    "b"
  ],
  "transitions": [
    [
      1,
      2
    ],
    [
      1,
      2
    ],
    [
      1,
      2
    ]
  ],
  "start": 0,
  "accepting": [
    1,
    2
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/classes": [
    [
      0
    ],
    [
      1,
      2
    ]
  ],
  "/stateCount": 2,
  "/transitions": [
    [
      1,
      1
    ],
    [
      1,
      1
    ]
  ],
  "/accepting": [
    1
  ]
}
```

## DFA Equivalence Witness API

USD 3.00 per job.

Compare two total DFA languages and return an alphabet-order shortest distinguishing word. Up to 64 states per machine and 4096 state pairs. Null witness means no distinguishing word exists, not an empty word. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.columbia.edu](https://www.cs.columbia.edu/~aho/cs3261/Lectures/L2-Finite_Automata.html). No endorsement is implied.

Example input:

```json
{
  "alphabet": [
    "0",
    "1"
  ],
  "left": {
    "transitions": [
      [
        0,
        1
      ],
      [
        1,
        0
      ]
    ],
    "start": 0,
    "accepting": [
      0
    ]
  },
  "right": {
    "transitions": [
      [
        0,
        0
      ]
    ],
    "start": 0,
    "accepting": [
      0
    ]
  }
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/equivalent": false,
  "/witness": [
    "1"
  ],
  "/leftAccepts": false,
  "/rightAccepts": true
}
```

## DFA Fixed Length Word Count API

USD 3.00 per job.

Count accepted token words of one exact length using integer dynamic programming. Length at most 512. Decimal-string results are exact; no word enumeration. Explicit token alphabet and total transition table. At most 64 states and 16 alphabet symbols; state IDs start at zero. No regular-expression or source-code execution. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.columbia.edu](https://www.cs.columbia.edu/~aho/cs3261/Lectures/L2-Finite_Automata.html). No endorsement is implied.

Example input:

```json
{
  "alphabet": [
    "0",
    "1"
  ],
  "transitions": [
    [
      0,
      1
    ],
    [
      1,
      0
    ]
  ],
  "start": 0,
  "accepting": [
    0
  ],
  "length": 3
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/count": "4",
  "/byState": [
    "4",
    "4"
  ]
}
```

## DFA Language Finiteness API

USD 3.00 per job.

Detect productive reachable cycles and count a finite accepted language exactly. Cycles that cannot reach acceptance are irrelevant. Empty language has count zero and null maximum word length. Explicit token alphabet and total transition table. At most 64 states and 16 alphabet symbols; state IDs start at zero. No regular-expression or source-code execution. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.columbia.edu](https://www.cs.columbia.edu/~aho/cs3261/Lectures/L2-Finite_Automata.html). No endorsement is implied.

Example input:

```json
{
  "alphabet": [
    "a"
  ],
  "transitions": [
    [
      1
    ],
    [
      2
    ],
    [
      2
    ]
  ],
  "start": 0,
  "accepting": [
    1
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/finite": true,
  "/wordCount": "1",
  "/maximumWordLength": 1
}
```

## DFA Shortest Accepted Word API

USD 3.00 per job.

Find an alphabet-order shortest accepted token sequence. The empty sequence is valid if the start accepts; null marks an empty language. Explicit token alphabet and total transition table. At most 64 states and 16 alphabet symbols; state IDs start at zero. No regular-expression or source-code execution. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.columbia.edu](https://www.cs.columbia.edu/~aho/cs3261/Lectures/L2-Finite_Automata.html). No endorsement is implied.

Example input:

```json
{
  "alphabet": [
    "a",
    "b"
  ],
  "transitions": [
    [
      0,
      1
    ],
    [
      1,
      1
    ]
  ],
  "start": 0,
  "accepting": [
    1
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/empty": false,
  "/word": [
    "b"
  ],
  "/length": 1
}
```

## Grammar FIRST FOLLOW Sets API

USD 3.00 per job.

Compute nullable, FIRST and FOLLOW sets by fixed point for a supplied token grammar. Reserve $ as end marker; keep nullable separate from FIRST. Up to 32 nonterminals, 32 terminals, 128 rules and 16 right-side symbols. This does not certify LL(1) suitability. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.columbia.edu](https://www.cs.columbia.edu/~aho/cs4115_Fall-2009/lectures/09-10-12.html). No endorsement is implied.

Example input:

```json
{
  "start": "S",
  "nonterminals": [
    "S",
    "A"
  ],
  "terminals": [
    "a",
    "b"
  ],
  "productions": [
    {
      "left": "S",
      "right": [
        "A",
        "b"
      ]
    },
    {
      "left": "A",
      "right": [
        "a"
      ]
    },
    {
      "left": "A",
      "right": []
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/nullable": [
    "A"
  ],
  "/first/S": [
    "a",
    "b"
  ],
  "/first/A": [
    "a"
  ],
  "/follow/S": [
    "$"
  ],
  "/follow/A": [
    "b"
  ]
}
```

## CNF CYK Membership API

USD 3.00 per job.

Recognize a token sequence using a supplied Chomsky-normal-form grammar. Only A-to-BC, A-to-terminal and optional start-to-empty rules; reject unsupported conversion requests. At most 32 tokens and 128 rules. No ambiguity count or parse-tree recovery. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [ocw.mit.edu](https://ocw.mit.edu/courses/18-404j-theory-of-computation-fall-2020/). No endorsement is implied.

Example input:

```json
{
  "start": "S",
  "nonterminals": [
    "S",
    "A",
    "B"
  ],
  "terminals": [
    "a",
    "b"
  ],
  "productions": [
    {
      "left": "S",
      "right": [
        "A",
        "B"
      ]
    },
    {
      "left": "A",
      "right": [
        "a"
      ]
    },
    {
      "left": "B",
      "right": [
        "b"
      ]
    }
  ],
  "word": [
    "a",
    "b"
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/accepted": true,
  "/topCell": [
    "S"
  ],
  "/spanCount": 3
}
```

## PNG IHDR Header Inspector API

USD 3.00 per job.

Inspect PNG signature and IHDR fields in an explicit header prefix. Require33 bytes including13-byte IHDR and verify its CRC. Header profile only: no IDAT decode, full-file validity, animation or rendering claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.w3.org](https://www.w3.org/TR/png-3/). No endorsement is implied.

Example input:

```json
{
  "hex": "89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c489"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/width": 1,
  "/height": 1,
  "/bitDepth": 8,
  "/colorType": 6,
  "/interlaceMethod": 0,
  "/headerBytes": 33
}
```

## GIF Logical Screen Inspector API

USD 3.00 per job.

Inspect a GIF87a/89a prefix and logical screen descriptor. Require13-byte header/descriptor. Color table and image blocks may be absent in this prefix; no LZW decode, frame count or complete-file claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.w3.org](https://www.w3.org/Graphics/GIF/spec-gif89a.txt). No endorsement is implied.

Example input:

```json
{
  "hex": "47494638396102000300800000"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/version": "89a",
  "/width": 2,
  "/height": 3,
  "/globalColorTable": true,
  "/globalColorTableEntries": 2,
  "/headerBytes": 13
}
```

## BMP Info Header Inspector API

USD 3.00 per job.

Read the Windows BITMAPFILEHEADER and 40-byte BITMAPINFOHEADER. Windows BM file header plus 40-byte BITMAPINFOHEADER prefix, at least54 bytes. Support uncompressed RGB, RLE4/RLE8 and 16/32-bit bitfields header declarations; reject other DIB/compression profiles. Pixel data, palettes and bit masks are not decoded or qualified; no complete-file claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [learn.microsoft.com](https://learn.microsoft.com/en-us/windows/win32/gdi/bitmap-storage). No endorsement is implied.

Example input:

```json
{
  "hex": "424d3a0000000000000036000000280000000100000001000000010018000000000004000000130b0000130b00000000000000000000"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/width": 1,
  "/height": 1,
  "/bitsPerPixel": 24,
  "/compression": 0,
  "/pixelOffset": 54,
  "/declaredFileSize": 58,
  "/topDown": false
}
```

## RIFF WAVE PCM Inspector API

USD 3.00 per job.

Inspect bounded RIFF chunks and derive PCM frame count and duration. At most64KiB, little-endian RIFF/WAVE PCM format1 only, exactly one fmt/data, valid padding/chunk bounds and byte-rate/block-align consistency; no audio decode. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [learn.microsoft.com](https://learn.microsoft.com/en-us/windows/win32/xaudio2/resource-interchange-file-format--riff-). No endorsement is implied.

Example input:

```json
{
  "hex": "524946462800000057415645666d74201000000001000100401f0000803e000002001000646174610400000000000000"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/channels": 1,
  "/sampleRate": 8000,
  "/bitsPerSample": 16,
  "/sampleFrames": 2,
  "/durationSeconds": 0.00025,
  "/dataBytes": 4
}
```

## MIDI File Header Inspector API

USD 3.00 per job.

Read Standard MIDI File format, track declaration and PPQN/SMPTE timing division. Require14-byte MThd prefix and chunk length6. Header-only; no MTrk event parsing, actual track count, playback duration or full-file claim. Official download availability recorded separately. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [midi.org](https://midi.org/standard-midi-files). No endorsement is implied.

Example input:

```json
{
  "hex": "4d546864000000060001000201e0"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/format": 1,
  "/declaredTracks": 2,
  "/timingMode": "ppqn",
  "/ticksPerQuarter": 480,
  "/headerBytes": 14
}
```

## Ogg Page Header Inspector API

USD 3.00 per job.

Inspect an Ogg v0 fixed header and lacing table without decoding packets. Prefix requires27-byte header plus full lacing table. Decode unsigned granule as decimal string/null sentinel; no body, page CRC, codec or complete-stream validation claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.rfc-editor.org](https://www.rfc-editor.org/rfc/rfc3533). No endorsement is implied.

Example input:

```json
{
  "hex": "4f676753000200000000000000000100000000000000000000000101"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/version": 0,
  "/beginningOfStream": true,
  "/serialNumber": 1,
  "/sequenceNumber": 0,
  "/segmentCount": 1,
  "/declaredBodyBytes": 1,
  "/headerBytes": 28
}
```

## FLAC Streaminfo Inspector API

USD 3.00 per job.

Inspect the native FLAC marker and first STREAMINFO metadata block. Require42-byte marker+STREAMINFO prefix, metadata type0 length34. Zero frame-size/MD5 fields mean unknown; no frame decode, MD5 or complete-stream qualification. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.rfc-editor.org](https://www.rfc-editor.org/rfc/rfc9639). No endorsement is implied.

Example input:

```json
{
  "hex": "664c614380000022100010000000000000000ac442f00000ac4400000000000000000000000000000000"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/sampleRate": 44100,
  "/channels": 2,
  "/bitsPerSample": 16,
  "/totalSamples": "44100",
  "/minimumBlockSize": 4096,
  "/maximumBlockSize": 4096,
  "/durationSeconds": 1
}
```

## JPEG Frame Header Inspector API

USD 3.00 per job.

Read precision, dimensions and component declarations from a bounded JPEG SOF prefix. At most64KiB; marker scan only through supported SOF0/SOF2 before SOS with strict segment bounds. No entropy decode, scan validity or complete-image claim; ITU T.81 full text paywalled. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [github.com](https://github.com/libjpeg-turbo/libjpeg-turbo/blob/main/src/jdmarker.c). No endorsement is implied.

Example input:

```json
{
  "hex": "ffd8ffc00011080001000203011100021100031100"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/frameType": "baseline-dct",
  "/precision": 8,
  "/width": 2,
  "/height": 1,
  "/components": 3
}
```

## ZIP Central Directory Inspector API

USD 3.00 per job.

Inspect a bounded single-disk ZIP directory and cross-check entry metadata without extraction. Bounded single-disk ZIP directory inspection, up to 64KiB and256 entries, also subject to shared input-byte/node limits. Support stored/deflate entry metadata and ASCII or flagged strict UTF8 names; reject encryption, ZIP64 and overlapping/mismatched local records. Cross-check optional 32-bit data descriptors. No extraction, decompression, payload CRC verification or filesystem writes; names are metadata only. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [pkware.cachefly.net](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT). No endorsement is implied.

Example input:

```json
{
  "hex": "504b0506000000000000000000000000000000000000"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/entryCount": 0,
  "/centralDirectoryBytes": 0,
  "/centralDirectoryOffset": 0,
  "/comment": "",
  "/zip64": false
}
```

## PE COFF Header Inspector API

USD 3.00 per job.

Read the PE signature and following COFF file header from an explicit prefix. Input begins at PE signature, not DOS MZ file start;24-byte prefix only. No optional-header/section/publisher/signature/safety validation, executable loading or machine access. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [learn.microsoft.com](https://learn.microsoft.com/en-us/windows/win32/debug/pe-format). No endorsement is implied.

Example input:

```json
{
  "hex": "5045000064860300000000000000000000000000f0002200"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/machine": 34404,
  "/machineName": "amd64",
  "/sections": 3,
  "/optionalHeaderBytes": 240,
  "/characteristics": 34,
  "/headerBytes": 24
}
```

## Pareto Option Frontier Report

USD 19.00 per job.

Identify nondominated supplied alternatives without inventing criterion weights. Dominance means no worse on every criterion and strictly better on at least one. Finite options only; no recommendation or outcome guarantee. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [web.stanford.edu](https://web.stanford.edu/~boyd/cvxbook/bv_cvxbook.pdf). No endorsement is implied.

Example input:

```json
{
  "directions": [
    "min",
    "max"
  ],
  "options": [
    {
      "id": "A",
      "values": [
        2,
        8
      ]
    },
    {
      "id": "B",
      "values": [
        3,
        7
      ]
    },
    {
      "id": "C",
      "values": [
        4,
        10
      ]
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/frontier": [
    "A",
    "C"
  ],
  "/dominated/B": [
    "A"
  ]
}
```

## Borda Panel Preference Report

USD 19.00 per job.

Aggregate complete strict team rankings using option-count-minus-one through zero points. Ballot multiplicities are positive integers; preserve equal top scores as a tie. Internal preference tally only. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [plato.stanford.edu](https://plato.stanford.edu/entries/voting-methods/). No endorsement is implied.

Example input:

```json
{
  "ballots": [
    {
      "count": 3,
      "ranking": [
        "A",
        "B",
        "C"
      ]
    },
    {
      "count": 2,
      "ranking": [
        "B",
        "C",
        "A"
      ]
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/scores": {
    "A": 6,
    "B": 7,
    "C": 2
  },
  "/winners": [
    "B"
  ]
}
```

## Condorcet Panel Cycle Report

USD 19.00 per job.

Report pairwise majority margins, a strict Condorcet winner when present, and directed majority cycles. Complete strict ballots only; no unique compromise is asserted when the rule has no winner. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [plato.stanford.edu](https://plato.stanford.edu/entries/voting-methods/). No endorsement is implied.

Example input:

```json
{
  "ballots": [
    {
      "count": 1,
      "ranking": [
        "A",
        "B",
        "C"
      ]
    },
    {
      "count": 1,
      "ranking": [
        "B",
        "C",
        "A"
      ]
    },
    {
      "count": 1,
      "ranking": [
        "C",
        "A",
        "B"
      ]
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/winner": null,
  "/margins/A/B": 1,
  "/margins/B/C": 1,
  "/margins/C/A": 1,
  "/hasCycle": true
}
```

## Instant Runoff Panel Count

USD 19.00 per job.

Rehearse internal instant-runoff elimination with complete ballots. Caller supplies a full tieOrder from most to least preferred; the last-listed tied minimum is eliminated. Ties are disclosed. This is not statutory election compliance. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.aec.gov.au](https://www.aec.gov.au/learn/preferential-voting.htm). No endorsement is implied.

Example input:

```json
{
  "ballots": [
    {
      "count": 4,
      "ranking": [
        "A",
        "B",
        "C"
      ]
    },
    {
      "count": 3,
      "ranking": [
        "B",
        "C",
        "A"
      ]
    },
    {
      "count": 2,
      "ranking": [
        "C",
        "B",
        "A"
      ]
    }
  ],
  "tieOrder": [
    "A",
    "B",
    "C"
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/rounds/0/tallies": {
    "A": 4,
    "B": 3,
    "C": 2
  },
  "/rounds/0/eliminated": "C",
  "/winner": "B",
  "/finalTallies": {
    "A": 4,
    "B": 5
  }
}
```

## Approval Panel Tally Report

USD 19.00 per job.

Count at most one approval per option per ballot. Blank ballots are retained; no approvals produce no winner. Preserve tied top counts and do not infer preference intensity. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [plato.stanford.edu](https://plato.stanford.edu/entries/voting-methods/). No endorsement is implied.

Example input:

```json
{
  "options": [
    "A",
    "B",
    "C"
  ],
  "ballots": [
    [
      "A",
      "B"
    ],
    [
      "B"
    ],
    [
      "A",
      "C"
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/counts": {
    "A": 2,
    "B": 2,
    "C": 1
  },
  "/winners": [
    "A",
    "B"
  ],
  "/ballotCount": 3
}
```

## Shapley Coalition Allocation Report

USD 19.00 per job.

Allocate supplied hypothetical coalition values by average marginal contribution. Provide all 2^n coalitions for at most eight participants, zero empty-coalition value, and comma-joined keys in participants order. Approximate numeric fractions, no entitlement or invoice instructions. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [ocw.mit.edu](https://ocw.mit.edu/courses/14-16-strategy-and-information-spring-2016/). No endorsement is implied.

Example input:

```json
{
  "participants": [
    "A",
    "B"
  ],
  "coalitionValues": {
    "": 0,
    "A": 10,
    "B": 20,
    "A,B": 50
  }
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/allocation": {
    "A": 20,
    "B": 30
  },
  "/allocatedTotal": 50
}
```

## Banzhaf Voting Power Profile

USD 19.00 per job.

Enumerate critical coalition swings for up to twelve weighted participants. Nominal weight differs from measured swing power. No swings produce null normalized power. Hypothetical rule analysis, not governance certification. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [pubsonline.informs.org](https://pubsonline.informs.org/doi/pdf/10.1287/moor.4.2.99). No endorsement is implied.

Example input:

```json
{
  "quota": 3,
  "weights": {
    "A": 2,
    "B": 1,
    "C": 1
  }
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/swings": {
    "A": 3,
    "B": 1,
    "C": 1
  },
  "/normalizedPower": {
    "A": 0.6,
    "B": 0.2,
    "C": 0.2
  }
}
```

## Weighted Nash Surplus Share Scenario

USD 19.00 per job.

Split a divisible surplus above supplied disagreement amounts using positive bargaining exponents and linear transferable utility. No extra constraints. Unrepresentable product is null with finite log product retained. Mathematical scenario, not negotiation advice. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [web.stanford.edu](https://web.stanford.edu/~rjohari/teaching/notes/246_lecture5_2007.pdf). No endorsement is implied.

Example input:

```json
{
  "total": 100,
  "disagreement": {
    "A": 10,
    "B": 20
  },
  "weights": {
    "A": 1,
    "B": 1
  }
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/allocation": {
    "A": 45,
    "B": 55
  },
  "/surplus": 70,
  "/nashProduct": 1225
}
```

## Max Min Capacity Share Plan

USD 19.00 per job.

Use progressive water filling to share one divisible pool with equal priority under individual nonnegative demand caps. Excess capacity is unused; no scheduling, reservations or allocation writes. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [web.stanford.edu](https://web.stanford.edu/~boyd/cvxbook/bv_cvxbook.pdf). No endorsement is implied.

Example input:

```json
{
  "capacity": 12,
  "demands": {
    "A": 2,
    "B": 10,
    "C": 10
  }
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/allocation": {
    "A": 2,
    "B": 5,
    "C": 5
  },
  "/unusedCapacity": 0,
  "/waterLevel": 5
}
```

## Jefferson Budget Unit Allocation

USD 19.00 per job.

Apportion an integer planning pool using Jefferson or D’Hondt highest averages. At most 10000 units and 32 weights; exact integer comparisons, ties favor object-key input order. This differs from largest remainders and can favor larger weights. No official apportionment certification. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.census.gov](https://www.census.gov/about/history/historical-censuses-and-surveys/census-programs-surveys/decennial-census/methods.html). No endorsement is implied.

Example input:

```json
{
  "units": 10,
  "weights": {
    "A": 47,
    "B": 31,
    "C": 22
  }
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/allocation": {
    "A": 5,
    "B": 3,
    "C": 2
  },
  "/allocatedUnits": 10
}
```

## Disjoint Set Operation Trace API

USD 3.00 per job.

Rehearse union and connectivity operations with a reconciled component partition. 1..4096 members and operations; validate indices. Canonical returned groups sorted by smallest member independently of internal root choice; in-memory rehearsal only. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [algs4.cs.princeton.edu](https://algs4.cs.princeton.edu/code/javadoc/edu/princeton/cs/algs4/WeightedQuickUnionUF.html). No endorsement is implied.

Example input:

```json
{
  "size": 5,
  "operations": [
    {
      "op": "union",
      "a": 0,
      "b": 1
    },
    {
      "op": "union",
      "a": 1,
      "b": 2
    },
    {
      "op": "connected",
      "a": 0,
      "b": 2
    },
    {
      "op": "connected",
      "a": 0,
      "b": 4
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/answers": [
    true,
    false
  ],
  "/components": [
    [
      0,
      1,
      2
    ],
    [
      3
    ],
    [
      4
    ]
  ],
  "/componentCount": 3
}
```

## Binary Min Heap Trace API

USD 3.00 per job.

Rehearse numeric pushes, peeks and pops in a binary min heap. At most4096 operations and integer priorities from-1e9 through1e9, also shared input limits. Zero-based binary heap; only strict inequality swaps, and left child wins equal priorities. Empty pop/peek returns null. Pure in-memory rehearsal. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [algs4.cs.princeton.edu](https://algs4.cs.princeton.edu/24pq/). No endorsement is implied.

Example input:

```json
{
  "operations": [
    {
      "op": "push",
      "value": 3
    },
    {
      "op": "push",
      "value": 1
    },
    {
      "op": "push",
      "value": 2
    },
    {
      "op": "pop"
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/popped": [
    1
  ],
  "/heap": [
    2,
    3
  ],
  "/size": 2
}
```

## Fenwick Prefix Sum Trace API

USD 3.00 per job.

Rehearse point additions and half-open prefix/range sum queries. 1..4096 initial integer values and at most4096 operations, each supplied value/delta within±1e9, plus shared input limits. Point additions and half-open ranges[start,end), including empty ranges; prefix end may be zero. Public indices are zero-based; tree includes zero dummy cell. BigInt internal sums; no storage changes. Integer result fields use numbers through absolute999999999999 and exact decimal strings beyond that, so shared numerical display rounding cannot change integer results. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [onlinelibrary.wiley.com](https://onlinelibrary.wiley.com/doi/abs/10.1002/spe.4380240306). No endorsement is implied.

Example input:

```json
{
  "values": [
    1,
    2,
    3,
    4
  ],
  "operations": [
    {
      "op": "prefix",
      "end": 3
    },
    {
      "op": "add",
      "index": 1,
      "delta": 5
    },
    {
      "op": "range",
      "start": 1,
      "end": 4
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/answers": [
    6,
    14
  ],
  "/values": [
    1,
    7,
    3,
    4
  ],
  "/tree": [
    0,
    1,
    8,
    3,
    15
  ]
}
```

## Range Add Min Sum Trace API

USD 3.00 per job.

Rehearse lazy segment-tree range additions and minimum/sum queries. Lazy segment-tree additions and minimum/sum queries,1..2048 integer values and at most2048 operations, supplied values/deltas within±1e9 plus shared input limits. Every interval is nonempty[start,end), zero-based. BigInt internal values and sums; no external mutation. Integer result fields use numbers through absolute999999999999 and exact decimal strings beyond that, so shared numerical display rounding cannot change integer results. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [algs4.cs.princeton.edu](https://algs4.cs.princeton.edu/code/javadoc/edu/princeton/cs/algs4/SegmentTree.html). No endorsement is implied.

Example input:

```json
{
  "values": [
    5,
    2,
    7,
    1
  ],
  "operations": [
    {
      "op": "add",
      "start": 1,
      "end": 3,
      "delta": -3
    },
    {
      "op": "query",
      "start": 0,
      "end": 4
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/answers": [
    {
      "minimum": -1,
      "sum": 9
    }
  ],
  "/values": [
    5,
    -1,
    4,
    1
  ]
}
```

## Trie Prefix Dictionary Profile API

USD 3.00 per job.

Build a token trie and answer exact-prefix listing and longest stored prefix queries. At most1024 ASCII words, each<=128 bytes and total<=64KiB. Deduplicate words; lexicographic match order; empty word allowed with explicit terminal marker. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [algs4.cs.princeton.edu](https://algs4.cs.princeton.edu/code/javadoc/edu/princeton/cs/algs4/TrieST.html). No endorsement is implied.

Example input:

```json
{
  "words": [
    "car",
    "cart",
    "cat",
    "dog"
  ],
  "prefix": "ca",
  "text": "carton"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/wordCount": 4,
  "/prefixMatches": [
    "car",
    "cart",
    "cat"
  ],
  "/longestStoredPrefix": "cart"
}
```

## LRU Cache Access Rehearsal API

USD 3.00 per job.

Simulate a fixed-capacity key cache with least-recently-used eviction. Capacity1..1024 and<=4096 string accesses. Miss inserts, every access becomes most recent; key membership only, no TTL,cost,persistence or real caching change. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.princeton.edu](https://www.cs.princeton.edu/courses/archive/spring17/cos226/exams/practice-design-s17.pdf). No endorsement is implied.

Example input:

```json
{
  "capacity": 2,
  "accesses": [
    "a",
    "b",
    "a",
    "c",
    "b"
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/hits": 1,
  "/misses": 4,
  "/evicted": [
    "b",
    "a"
  ],
  "/leastToMostRecent": [
    "c",
    "b"
  ]
}
```

## Linear Probing Hash Trace API

USD 3.00 per job.

Rehearse bounded open-address hash insertion/search/deletion with tombstones. Capacity1..1024,at most4096 operations and nonnegative integer keys through1e9, also shared input limits. home=key mod capacity; step1, no resizing. Tombstones are literal "deleted" distinct from never-used null. Find probes count visited slots including the terminating null; absent after a full cycle uses capacity probes. Duplicate insert does not change size. Full insert is recorded as inserted:false,full:true rather than silently discarded. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [algs4.cs.princeton.edu](https://algs4.cs.princeton.edu/lectures/keynote/34HashTables.pdf). No endorsement is implied.

Example input:

```json
{
  "capacity": 5,
  "operations": [
    {
      "op": "insert",
      "key": 1
    },
    {
      "op": "insert",
      "key": 6
    },
    {
      "op": "insert",
      "key": 11
    },
    {
      "op": "find",
      "key": 11
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/slots": [
    null,
    1,
    6,
    11,
    null
  ],
  "/finds": [
    {
      "key": 11,
      "found": true,
      "index": 3,
      "probes": 3
    }
  ],
  "/size": 3
}
```

## Count Min Sketch Rehearsal API

USD 3.00 per job.

Build a deterministic frequency sketch from explicit integer hash coefficients and positive updates. Width1..1024,depth1..16,validated prime2..65521,nonnegative keys through1e9,positive update counts through1e9,and at most4096 updates/queries subject to shared input limits. Explicit a in1..prime-1 and b in0..prime-1; hash=((a*key+b) mod prime) mod width computed with BigInt. User-fixed hashes provide deterministic results, with no probabilistic error or cryptographic guarantee. Integer result fields use numbers through absolute999999999999 and exact decimal strings beyond that, so shared numerical display rounding cannot change integer results. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [dimacs.rutgers.edu](https://dimacs.rutgers.edu/~graham/pubs/papers/cm-full.pdf). No endorsement is implied.

Example input:

```json
{
  "width": 4,
  "prime": 17,
  "hashes": [
    {
      "a": 1,
      "b": 0
    },
    {
      "a": 3,
      "b": 1
    }
  ],
  "updates": [
    {
      "key": 1,
      "count": 2
    },
    {
      "key": 5,
      "count": 3
    }
  ],
  "queries": [
    1,
    5
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/table": [
    [
      0,
      5,
      0,
      0
    ],
    [
      5,
      0,
      0,
      0
    ]
  ],
  "/estimates": [
    5,
    5
  ],
  "/totalCount": 5
}
```

## Bitvector Rank Select Index API

USD 3.00 per job.

Answer exact prefix-rank and one-based occurrence-select queries on a bit vector. At most16384 bits and4096 total queries, also shared6000-node/36000-byte input limits. rank(end) counts ones in[0,end), with end0 allowed. select(k) uses one-based occurrence and returns zero-based position or null. Empty bit vectors are allowed; no compressed-space claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [arxiv.org](https://arxiv.org/abs/2206.01149). No endorsement is implied.

Example input:

```json
{
  "bits": [
    1,
    0,
    1,
    1,
    0
  ],
  "rankEnds": [
    0,
    3,
    5
  ],
  "selectOrdinals": [
    1,
    3,
    4
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/ranks": [
    0,
    2,
    3
  ],
  "/selectPositions": [
    0,
    3,
    null
  ],
  "/ones": 3
}
```

## KD Point Nearest Neighbors API

USD 3.00 per job.

Return exact Euclidean nearest neighbors of bounded two-dimensional point queries. Balanced median-split two-dimensional KD tree for1..1024 supplied points and at most256 queries, each finite coordinate within±1e9, plus shared input limits. Euclidean squared distances use ordinary IEEE754 arithmetic and twelve-significant-digit display; equal computed distances choose the smallest original point index. No approximate-neighbor or high-dimensional performance claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.princeton.edu](https://www.cs.princeton.edu/courses/archive/fall12/cos226/assignments/kdtree.html). No endorsement is implied.

Example input:

```json
{
  "points": [
    [
      0,
      0
    ],
    [
      2,
      0
    ],
    [
      1,
      2
    ]
  ],
  "queries": [
    [
      1.8,
      0.1
    ],
    [
      1,
      1.8
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/nearestIndices": [
    1,
    2
  ],
  "/squaredDistances": [
    0.05,
    0.04
  ]
}
```

## Two Level Factorial Effects Report

USD 19.00 per job.

Extract all main and interaction effects from a complete balanced two-level factorial experiment. One through six distinct single uppercase factor letters (I reserved for identity), coded levels -1/+1, at most256 runs. Every factorial cell must have equal positive replication. Effects are high-minus-low contrasts; no inferential p-values. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [itl.nist.gov](https://itl.nist.gov/div898/handbook/pri/section4/pri43.htm). No endorsement is implied.

Example input:

```json
{
  "factors": [
    "A",
    "B"
  ],
  "runs": [
    {
      "levels": [
        -1,
        -1
      ],
      "response": 10
    },
    {
      "levels": [
        1,
        -1
      ],
      "response": 14
    },
    {
      "levels": [
        -1,
        1
      ],
      "response": 16
    },
    {
      "levels": [
        1,
        1
      ],
      "response": 24
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/grandMean": 16,
  "/effects/A": 6,
  "/effects/B": 8,
  "/effects/AB": 2
}
```

## Randomized Block Decomposition

USD 19.00 per job.

Separate treatment, block and residual sums of squares for a complete additive block experiment. One observation per block-treatment cell; no interaction estimate. Zero error yields undefined F, never infinity-as-evidence. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.itl.nist.gov](https://www.itl.nist.gov/div898/handbook/pri/section3/pri3.htm). No endorsement is implied.

Example input:

```json
{
  "blocks": [
    [
      1,
      3
    ],
    [
      2,
      4
    ],
    [
      3,
      5
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/grandMean": 3,
  "/treatmentSS": 6,
  "/blockSS": 4,
  "/errorSS": 0,
  "/totalSS": 10
}
```

## Latin Square Experiment Decomposition

USD 19.00 per job.

Adjust treatment variation for two blocking directions in a valid Latin square. Each treatment exactly once per row/column; additive effects and no interactions. Planning evidence only. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.itl.nist.gov](https://www.itl.nist.gov/div898/handbook/pri/section3/pri3.htm). No endorsement is implied.

Example input:

```json
{
  "treatments": [
    [
      "A",
      "B",
      "C"
    ],
    [
      "B",
      "C",
      "A"
    ],
    [
      "C",
      "A",
      "B"
    ]
  ],
  "values": [
    [
      1,
      3,
      5
    ],
    [
      5,
      7,
      6
    ],
    [
      9,
      8,
      10
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/grandMean": 6,
  "/rowSS": 54,
  "/columnSS": 6,
  "/treatmentSS": 6,
  "/errorSS": 0,
  "/totalSS": 66
}
```

## Central Composite Run Plan

USD 19.00 per job.

Generate factorial, axial and center run coordinates for a bounded quadratic-response experiment. Coded coordinates only, no equipment execution or suggested safe physical range; deterministic order, not randomized execution. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.itl.nist.gov](https://www.itl.nist.gov/div898/handbook/pri/section3/pri3.htm). No endorsement is implied.

Example input:

```json
{
  "factorCount": 2,
  "alpha": 2,
  "centerReplicates": 1
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/runCount": 9,
  "/factorialRunCount": 4,
  "/axialRunCount": 4,
  "/centerRunCount": 1,
  "/axialPoints": [
    [
      -2,
      0
    ],
    [
      2,
      0
    ],
    [
      0,
      -2
    ],
    [
      0,
      2
    ]
  ]
}
```

## Fractional Factorial Alias Map

USD 19.00 per job.

Multiply defining words over GF(2) to expose confounded terms in a regular two-level fraction. Regular positive defining relations, up to10 distinct uppercase factor letters excluding I, and six generating words. Each word uses each declared factor at most once. XOR closure includes dependent generators; resolution is shortest nonidentity word. No effect insignificance assumption. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.itl.nist.gov](https://www.itl.nist.gov/div898/handbook/pri/section3/pri3343.htm). No endorsement is implied.

Example input:

```json
{
  "factors": [
    "A",
    "B",
    "C"
  ],
  "definingWords": [
    "ABC"
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/resolution": 3,
  "/aliases/A": [
    "A",
    "BC"
  ],
  "/aliases/B": [
    "B",
    "AC"
  ],
  "/aliases/C": [
    "C",
    "AB"
  ]
}
```

## Box Cox Likelihood Grid

USD 19.00 per job.

Evaluate caller-selected power transformations and Gaussian profile likelihood on positive observations. Three through128 positive nonconstant observations, up to31 distinct powers in[-5,5]. Use natural logarithm at lambda0, population-denominator transformed variance and the Jacobian term. Tied likelihood maxima favor input lambda order; no normality guarantee. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.boxcox_llf.html). No endorsement is implied.

Example input:

```json
{
  "values": [
    1,
    2,
    4
  ],
  "lambdas": [
    0,
    1
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/bestLambda": 0,
  "/transforms/1": [
    0,
    1,
    3
  ],
  "/transforms/0/0": 0,
  "/transforms/0/2": 1.3862943611198906
}
```

## Replicated Line Lack of Fit Report

USD 19.00 per job.

Decompose a straight-line residual into within-setting pure error and lack of fit. At least three distinct x settings with replication, common variance assumption; differs from an ordinary fitted line report. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.itl.nist.gov](https://www.itl.nist.gov/div898/handbook/pri/section4/pri43.htm). No endorsement is implied.

Example input:

```json
{
  "groups": [
    {
      "x": 0,
      "y": [
        0,
        2
      ]
    },
    {
      "x": 1,
      "y": [
        1,
        3
      ]
    },
    {
      "x": 2,
      "y": [
        4,
        6
      ]
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/pureErrorSS": 6,
  "/lackOfFitSS": 1.3333333333333333,
  "/pureErrorDf": 3,
  "/lackOfFitDf": 1,
  "/fStatistic": 0.6666666666666666
}
```

## Levene Median Variance Evidence

USD 19.00 per job.

Compare group dispersion using ANOVA of absolute deviations from each group median. Finite groups with residual variation; report the median-based Brown-Forsythe convention explicitly. No automatic practical-importance verdict. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [itl.nist.gov](https://itl.nist.gov/div898/handbook/eda/section3/eda35a.htm). No endorsement is implied.

Example input:

```json
{
  "groups": [
    [
      0,
      1,
      2
    ],
    [
      0,
      2,
      4
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/statistic": 0.8,
  "/numeratorDf": 1,
  "/denominatorDf": 4,
  "/centers": [
    1,
    2
  ]
}
```

## Bartlett Variance Evidence

USD 19.00 per job.

Calculate the likelihood-based homogeneity statistic from sample variances and sample sizes. Sensitive to nonnormal data; strictly positive group variances and at least two observations per group. No p-value required for the design fixture. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bartlett.html). No endorsement is implied.

Example input:

```json
{
  "groups": [
    [
      0,
      1,
      2
    ],
    [
      0,
      2,
      4
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/sampleVariances": [
    1,
    4
  ],
  "/pooledVariance": 2.5,
  "/degreesOfFreedom": 1,
  "/correctionFactor": 1.25
}
```

## Cochran Variance Dominance Report

USD 19.00 per job.

Identify whether one equal-sized laboratory group dominates the sum of group variances. Equal group sizes, positive total variance; C is descriptive without a justified critical-value source. Different target from overall homogeneity tests. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [itl.nist.gov](https://itl.nist.gov/div898/software/dataplot/refman1/auxillar/cochvari.htm). No endorsement is implied.

Example input:

```json
{
  "groups": [
    [
      0,
      1,
      2
    ],
    [
      0,
      2,
      4
    ],
    [
      0,
      3,
      6
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/sampleVariances": [
    1,
    4,
    9
  ],
  "/largestGroupIndex": 2,
  "/cStatistic": 0.6428571428571429
}
```

## Quaternion Vector Rotation API

USD 3.00 per job.

Normalize a nonzero quaternion and rotate supplied three-dimensional vectors. Quaternion order [x,y,z,w], Hamilton convention, active right-handed rotation. Up to1024 vectors; reject near-zero quaternion and nonfinite values; no coordinate-system inference. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.w3.org](https://www.w3.org/TR/webxr/). No endorsement is implied.

Example input:

```json
{
  "quaternion": [
    0,
    0,
    1,
    0
  ],
  "vectors": [
    [
      1,
      2,
      3
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/rotated": [
    [
      -1,
      -2,
      3
    ]
  ],
  "/normalizedQuaternion": [
    0,
    0,
    1,
    0
  ]
}
```

## Ray Triangle Intersection 3D API

USD 3.00 per job.

Intersect a nonzero-direction ray with a nondegenerate triangle, returning barycentric coordinates. Double-sided Moller-Trumbore, t>=0; determinant tolerance relative to input scale. Parallel/coplanar case reports no unique hit; no exact-predicate claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.tandfonline.com](https://www.tandfonline.com/doi/abs/10.1080/10867651.1997.10487468). No endorsement is implied.

Example input:

```json
{
  "origin": [
    0.25,
    0.25,
    1
  ],
  "direction": [
    0,
    0,
    -1
  ],
  "triangle": [
    [
      0,
      0,
      0
    ],
    [
      1,
      0,
      0
    ],
    [
      0,
      1,
      0
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/hit": true,
  "/t": 1,
  "/point": [
    0.25,
    0.25,
    0
  ],
  "/barycentric": [
    0.5,
    0.25,
    0.25
  ]
}
```

## Ray Axis Box Intersection API

USD 3.00 per job.

Compute the forward ray interval inside an axis-aligned three-dimensional box. Closed finite box with min<=max; nonzero direction. Slab method handles zero components without division; inside-origin enter=0. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.geometrictools.com](https://www.geometrictools.com/Source/Intersection3D.html). No endorsement is implied.

Example input:

```json
{
  "origin": [
    -1,
    0.5,
    0.5
  ],
  "direction": [
    1,
    0,
    0
  ],
  "minimum": [
    0,
    0,
    0
  ],
  "maximum": [
    1,
    1,
    1
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/hit": true,
  "/enter": 1,
  "/exit": 2,
  "/entryPoint": [
    0,
    0.5,
    0.5
  ]
}
```

## Point Plane Projection 3D API

USD 3.00 per job.

Project a point orthogonally onto n dot x + constant = 0. Nonzero finite normal; normalize distance by normal length. Sign follows supplied normal; reject overflow and degenerate normal. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.geometrictools.com](https://www.geometrictools.com/Source/Distance3D.html). No endorsement is implied.

Example input:

```json
{
  "point": [
    1,
    3,
    5
  ],
  "normal": [
    0,
    0,
    2
  ],
  "constant": -4
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/projection": [
    1,
    3,
    2
  ],
  "/signedDistance": 3,
  "/distance": 3
}
```

## Skew Line Closest Approach API

USD 3.00 per job.

Find nearest points on two nonparallel infinite three-dimensional lines. Infinite lines, not rays or segments. Both directions nonzero; parallel or ill-conditioned input explicitly rejects under a documented relative threshold. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.geometrictools.com](https://www.geometrictools.com/Source/Distance3D.html). No endorsement is implied.

Example input:

```json
{
  "originA": [
    0,
    0,
    0
  ],
  "directionA": [
    1,
    0,
    0
  ],
  "originB": [
    0,
    1,
    1
  ],
  "directionB": [
    0,
    1,
    0
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/pointA": [
    0,
    0,
    0
  ],
  "/pointB": [
    0,
    0,
    1
  ],
  "/parameterA": 0,
  "/parameterB": -1,
  "/distance": 1
}
```

## Tetrahedron Barycentric Profile API

USD 3.00 per job.

Express a point as barycentric weights in a nondegenerate tetrahedron. Weights correspond to supplied vertex order, sum1; inside includes boundary within declared tolerance. Reject degenerate/ill-conditioned tetrahedra. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [doc.cgal.org](https://doc.cgal.org/latest/Kernel_23/classCGAL_1_1Tetrahedron__3.html). No endorsement is implied.

Example input:

```json
{
  "vertices": [
    [
      0,
      0,
      0
    ],
    [
      1,
      0,
      0
    ],
    [
      0,
      1,
      0
    ],
    [
      0,
      0,
      1
    ]
  ],
  "point": [
    0.25,
    0.25,
    0.25
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/weights": [
    0.25,
    0.25,
    0.25,
    0.25
  ],
  "/inside": true,
  "/signedVolume": 0.166666666667
}
```

## Point Triangle Closest 3D API

USD 3.00 per job.

Locate the nearest point on a closed triangle, including edge and vertex regions. Nondegenerate finite 3D triangle. Approximate region predicates; reject degeneracy rather than silently collapsing to a segment. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.geometrictools.com](https://www.geometrictools.com/Source/Distance3D.html). No endorsement is implied.

Example input:

```json
{
  "point": [
    0.25,
    0.25,
    2
  ],
  "triangle": [
    [
      0,
      0,
      0
    ],
    [
      1,
      0,
      0
    ],
    [
      0,
      1,
      0
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/closest": [
    0.25,
    0.25,
    0
  ],
  "/distance": 2,
  "/barycentric": [
    0.5,
    0.25,
    0.25
  ]
}
```

## Oriented Triangle Mesh Volume API

USD 3.00 per job.

Calculate signed enclosed volume and surface area of a closed oriented triangle mesh. Up to 1024 vertices and 2048 nondegenerate triangles, also subject to the shared input-byte/node profile. Require every undirected edge twice with opposite directions. Algebraic signed volume and area; self-intersection and embedded-manifold validity are not certified. No file decoding or mesh repair. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [doc.cgal.org](https://doc.cgal.org/latest/Polygon_mesh_processing/group__PMP__measure__grp.html). No endorsement is implied.

Example input:

```json
{
  "vertices": [
    [
      0,
      0,
      0
    ],
    [
      1,
      0,
      0
    ],
    [
      0,
      1,
      0
    ],
    [
      0,
      0,
      1
    ]
  ],
  "faces": [
    [
      0,
      2,
      1
    ],
    [
      0,
      1,
      3
    ],
    [
      0,
      3,
      2
    ],
    [
      1,
      2,
      3
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/signedVolume": 0.166666666667,
  "/surfaceArea": 2.36602540378,
  "/closed": true,
  "/triangleCount": 4
}
```

## Sphere Sphere Overlap Volume API

USD 3.00 per job.

Compute intersection volume of two spheres with disjoint, containment and partial-overlap branches. Positive finite radii; Euclidean distance. Treat coincident centers without division; volume approximate, no physical collision-system claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [mathworld.wolfram.com](https://mathworld.wolfram.com/Sphere-SphereIntersection.html). No endorsement is implied.

Example input:

```json
{
  "centerA": [
    0,
    0,
    0
  ],
  "radiusA": 1,
  "centerB": [
    1,
    0,
    0
  ],
  "radiusB": 1
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/intersectionVolume": 1.308996939,
  "/fractionA": 0.3125,
  "/fractionB": 0.3125,
  "/relation": "partial-overlap"
}
```

## Rigid Transform Inverse 3D API

USD 3.00 per job.

Transform points and derive the inverse of a declared proper rigid transform. Row-major rotation applied to column vectors. Require orthonormal R and determinant+1 within documented tolerance; no scale/shear/reflection; <=1024 points. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.w3.org](https://www.w3.org/TR/webxr/). No endorsement is implied.

Example input:

```json
{
  "rotation": [
    [
      0,
      -1,
      0
    ],
    [
      1,
      0,
      0
    ],
    [
      0,
      0,
      1
    ]
  ],
  "translation": [
    1,
    2,
    3
  ],
  "points": [
    [
      2,
      0,
      0
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/points": [
    [
      1,
      4,
      3
    ]
  ],
  "/inverseRotation": [
    [
      0,
      1,
      0
    ],
    [
      -1,
      0,
      0
    ],
    [
      0,
      0,
      1
    ]
  ],
  "/inverseTranslation": [
    -2,
    1,
    -3
  ]
}
```

## Gini Lorenz Workload Profile

USD 19.00 per job.

Describe inequality of a supplied nonnegative workload distribution with the empirical Lorenz curve and population Gini. Positive aggregate workload; population Gini without n/(n-1) correction. Descriptive workload inequality, not a fairness or employment decision. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.worldbank.org](https://www.worldbank.org/en/topic/poverty/lac-equity-lab1/income-inequality/urban-rural-inequality). No endorsement is implied.

Example input:

```json
{
  "values": [
    0,
    0,
    10,
    10
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/gini": 0.5,
  "/lorenzPopulationShares": [
    0,
    0.25,
    0.5,
    0.75,
    1
  ],
  "/lorenzValueShares": [
    0,
    0,
    0,
    0.5,
    1
  ]
}
```

## Theil Group Dispersion Decomposition

USD 19.00 per job.

Separate total Theil-T dispersion into within-group and between-group components. Nonnegative values with positive mean, convention0*ln0=0; natural logs and value-share weighting. No automatic policy judgment. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [thedocs.worldbank.org](https://thedocs.worldbank.org/en/doc/090761b924a9ac7b9181f5d5de34910f-0050022021/original/hdR2005-Dikhanov-Yuri-8.pdf). No endorsement is implied.

Example input:

```json
{
  "groups": [
    {
      "id": "A",
      "values": [
        1,
        1
      ]
    },
    {
      "id": "B",
      "values": [
        2,
        2
      ]
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/theilT": 0.0566330122651324,
  "/withinGroup": 0,
  "/betweenGroup": 0.0566330122651324
}
```

## Cronbach Scale Consistency Report

USD 19.00 per job.

Evaluate covariance-based internal consistency of caller-provided multi-item survey scores. Complete numeric matrix, at least two items; alpha=k/(k-1)*(1-sum(item variances)/variance(total)). Does not prove one dimension, construct validity or suitability for individual decisions. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.ets.org](https://www.ets.org/research/policy_research_reports/publications/article/1951/dblr.html). No endorsement is implied.

Example input:

```json
{
  "respondents": [
    [
      1,
      2
    ],
    [
      2,
      4
    ],
    [
      3,
      6
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/itemVariances": [
    1,
    4
  ],
  "/totalScoreVariance": 9,
  "/alpha": 0.8888888888888888
}
```

## Wasserstein Operating Distribution Gap

USD 19.00 per job.

Measure the one-dimensional transport distance between supplied continuous operating samples. One-dimensional empirical Wasserstein-1 distance with equal observation weights, including unequal sample lengths. Integrates the absolute empirical CDF difference exactly between observed knots; values must use consistent units. No statistical significance or categorical drift claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.wasserstein_distance.html). No endorsement is implied.

Example input:

```json
{
  "a": [
    0,
    2
  ],
  "b": [
    1,
    5
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/wasserstein1": 2,
  "/sampleCountA": 2,
  "/sampleCountB": 2
}
```

## Hellinger Category Overlap Report

USD 19.00 per job.

Compare aligned category shares through square-root geometry and Bhattacharyya overlap. Normalize nonnegative counts with positive totals; H=sqrt(0.5*sum((sqrt(p)-sqrt(q))^2)). Zeros are valid; no smoothing or significance claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [elki-project.github.io](https://elki-project.github.io/releases/release0.7.5/doc/de/lmu/ifi/dbs/elki/distance/distancefunction/probabilistic/HellingerDistanceFunction.html). No endorsement is implied.

Example input:

```json
{
  "a": [
    1,
    0
  ],
  "b": [
    0,
    1
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/hellingerDistance": 1,
  "/bhattacharyyaCoefficient": 0,
  "/squaredHellinger": 1
}
```

## Categorical Mutual Information Report

USD 19.00 per job.

Quantify shared information between two categorical variables from a contingency count table. Descriptive empirical information, not a significance test or causal statement. Zero cells contribute0; positive grand total required. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [scikit-learn.org](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mutual_info_score.html). No endorsement is implied.

Example input:

```json
{
  "table": [
    [
      2,
      0
    ],
    [
      0,
      2
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/mutualInformationNats": 0.6931471805599453,
  "/entropyRowsNats": 0.6931471805599453,
  "/entropyColumnsNats": 0.6931471805599453
}
```

## Partition Variation of Information

USD 19.00 per job.

Quantify information lost and gained between two supplied partitions of the same records. Aligned record identities required; VI=H(A|B)+H(B|A), label names irrelevant. Measures partition change, without declaring a correct partition. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.sciencedirect.com](https://www.sciencedirect.com/science/article/pii/S0047259X06002016). No endorsement is implied.

Example input:

```json
{
  "partitionA": [
    "A",
    "A",
    "B",
    "B"
  ],
  "partitionB": [
    "X",
    "X",
    "X",
    "X"
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/variationInformationNats": 0.6931471805599453,
  "/conditionalAonB": 0.6931471805599453,
  "/conditionalBonA": 0
}
```

## Adjusted Rand Segmentation Agreement

USD 19.00 per job.

Compare two supplied segmentations by pair agreement adjusted for fixed-margin chance. Aligned nonempty records, exact pair counts and the fixed-margin adjusted Rand convention; no clustering is inferred. One record and equivalent all-one/all-singleton degenerate partitions return perfect agreement 1. Negative agreement is valid, without declaring a correct segmentation. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [scikit-learn.org](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.adjusted_rand_score.html). No endorsement is implied.

Example input:

```json
{
  "partitionA": [
    "A",
    "A",
    "B",
    "B"
  ],
  "partitionB": [
    "X",
    "Y",
    "X",
    "Y"
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/adjustedRandIndex": -0.5,
  "/sameInBothPairs": 0,
  "/totalPairs": 6
}
```

## Aitchison Composition Gap Report

USD 19.00 per job.

Compare two positive compositions by Euclidean distance between centered log ratios. Strictly positive matched components, invariant to uniform rescaling; no arbitrary zero replacement. Relative mix comparison differs from raw share drift. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [academic.oup.com](https://academic.oup.com/jrsssb/article/44/2/139/7027742). No endorsement is implied.

Example input:

```json
{
  "a": [
    1,
    1
  ],
  "b": [
    1,
    4
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/clrA": [
    0,
    0
  ],
  "/clrB": [
    -0.6931471805599453,
    0.6931471805599453
  ],
  "/aitchisonDistance": 0.9802581434685472
}
```

## Distance Correlation Dependence Profile

USD 19.00 per job.

Detect descriptive nonlinear dependence through double-centered pairwise distance matrices. Biased empirical V-statistic using n² divisor, numeric aligned observations, at most 128 per sequence. Double-centers full pairwise absolute-distance matrices; a constant variable returns zero distance correlation. Descriptive nonlinear dependence only, no significance or causal inference. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [dcor.readthedocs.io](https://dcor.readthedocs.io/en/latest/functions/dcor.distance_correlation_sqr.html). No endorsement is implied.

Example input:

```json
{
  "x": [
    -1,
    0,
    1
  ],
  "y": [
    1,
    0,
    1
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/distanceCovarianceSquared": 0.09876543209876543,
  "/squaredDistanceCorrelation": 0.31622776601683794,
  "/distanceCorrelation": 0.5623413251903491
}
```

## MessagePack JSON Subset Codec API

USD 3.00 per job.

Encode or decode a strict JSON-compatible MessagePack subset. Encode requires hex=""; decode requires value=null. Encoding rejects reserved object keys __proto__, constructor and prototype under the shared input safety policy. JSON-compatible MessagePack subset, 64KiB, depth16 and1024 total nodes including map keys, also shared input limits. Nil, booleans, safe integers, finite numeric doubles, strict UTF8 strings, arrays and unique string-key maps; no extensions or binary values. Decoded JSON is returned as valueJson text so common numerical display rounding cannot alter codec values. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [github.com](https://github.com/msgpack/msgpack/blob/master/spec.md). No endorsement is implied.

Example input:

```json
{
  "mode": "encode",
  "value": {
    "a": 1,
    "b": [
      true,
      null
    ]
  },
  "hex": ""
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/hex": "82a16101a16292c3c0",
  "/byteLength": 9
}
```

## BSON Core Document Codec API

USD 3.00 per job.

Encode or decode a small BSON core document without application object revival. Encode requires hex=""; decode requires value={}. Encoding rejects reserved object keys __proto__, constructor and prototype under the shared input safety policy. Core BSON documents/arrays, int32, finite doubles representing safe JSON numbers, UTF8 strings, booleans and null. No other BSON types or application revival. 64KiB, depth16 and1024 nested documents/elements, plus shared input limits. Reject duplicate keys, NUL keys and malformed arrays; decoded values are valueJson text to preserve numeric codec values. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [bsonspec.org](https://bsonspec.org/spec.html). No endorsement is implied.

Example input:

```json
{
  "mode": "encode",
  "value": {
    "answer": 42
  },
  "hex": ""
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/hex": "1100000010616e73776572002a00000000",
  "/byteLength": 17
}
```

## Bencode Value Codec API

USD 3.00 per job.

Encode or decode integer, byte-string, list and sorted-key dictionary bencoding. Encode requires encoded=""; decode requires value=null. Encoding rejects reserved object keys __proto__, constructor and prototype under the shared input safety policy. Safe JSON integers, strict UTF8 convenience strings, lists and dictionaries sorted by UTF8 key bytes. No arbitrary byte strings, null, booleans or floating values; reject -0, nonminimal lengths/integers and duplicate/unsorted keys. 64KiB, depth16,1024 nodes plus shared input limits. valueJson preserves decoded numeric values; no torrent/network action. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.bittorrent.org](https://www.bittorrent.org/beps/bep_0003.html). No endorsement is implied.

Example input:

```json
{
  "mode": "encode",
  "value": {
    "a": 1,
    "b": "xyz"
  },
  "encoded": ""
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/encoded": "d1:ai1e1:b3:xyze",
  "/byteLength": 16
}
```

## XDR Typed Value Pack API

USD 3.00 per job.

Encode or decode a supplied sequence of explicit XDR scalar and variable-opaque types. All modes require fields and hex. Encode requires hex=""; decode fields give each explicit type with value=null. int32,uint32,bool,strict UTF8 string and variable opaque hex only; big-endian words and zero padding. 64KiB and256 fields plus shared input limits; no RPC or inferred schema. Decoded fields are fieldsJson text. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.rfc-editor.org](https://www.rfc-editor.org/rfc/rfc4506). No endorsement is implied.

Example input:

```json
{
  "mode": "encode",
  "fields": [
    {
      "type": "int32",
      "value": -1
    },
    {
      "type": "string",
      "value": "A"
    }
  ],
  "hex": ""
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/hex": "ffffffff0000000141000000",
  "/byteLength": 12
}
```

## DER TLV Structure Inspector API

USD 3.00 per job.

Inspect a constrained definite-length ASN.1 TLV tree and primitive values. Constrained definite-length ASN.1 TLV structural inspection,64KiB,depth10,1024 nodes (nesting bounded by the shared result-depth profile); integers at most512 octets, OID arcs at most16 base128 octets and128 arcs. Enforce shortest tags/lengths and known primitive BOOLEAN/INTEGER/BIT STRING/NULL/OID restrictions; recurse constructed values. Unknown primitive tags remain raw. No ASN.1 schema, SET/SET OF semantic ordering, certificate, signature or full DER conformance certification. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.itu.int](https://www.itu.int/rec/dologin_pub.asp?id=T-REC-X.690-202102-I%21%21PDF-E&lang=e&type=items). No endorsement is implied.

Example input:

```json
{
  "hex": "3006020101020102"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/root/tag": 16,
  "/root/constructed": true,
  "/root/length": 6,
  "/root/children/0/integer": "1",
  "/root/children/1/integer": "2",
  "/byteLength": 8
}
```

## UTF8 Netstring Codec API

USD 3.00 per job.

Frame or split strict UTF8 strings with decimal byte lengths and comma terminators. Encode requires hex=""; decode requires values=[]. Strict UTF8 strings framed by decimal UTF8 byte length, colon and comma. 64KiB,1024 frames plus shared input limits; no leading length zeros except0, complete consumption required. This is a restricted UTF8 convenience codec based on the original expired netstrings draft, not an Internet Standard. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [datatracker.ietf.org](https://datatracker.ietf.org/doc/html/draft-bernstein-netstrings-02). No endorsement is implied.

Example input:

```json
{
  "mode": "encode",
  "values": [
    "abc",
    "",
    "é"
  ],
  "hex": ""
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/hex": "333a6162632c303a2c323ac3a92c",
  "/byteLength": 14,
  "/lengths": [
    3,
    0,
    2
  ]
}
```

## Intel HEX Record Profile API

USD 3.00 per job.

Validate record lengths/checksums and reconstruct a bounded sparse byte-address map. 64KiB text,<=1024 records; support00,01,02,03,04,05 with exact sizes and single EOF; reject overlapping addresses/trailing records. No firmware execution, flashing or file writes. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.keil.com](https://www.keil.com/support/docs/1584/_hlp_hexfile.htm). No endorsement is implied.

Example input:

```json
{
  "text": ":0400100001020304E2\n:00000001FF"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/dataBytes": 4,
  "/minimumAddress": 16,
  "/maximumAddressExclusive": 20,
  "/segments": [
    {
      "address": 16,
      "hex": "01020304"
    }
  ],
  "/recordCount": 2
}
```

## Motorola S Record Profile API

USD 3.00 per job.

Validate Motorola S-record counts/checksums and reconstruct sparse data segments. At most64KiB text and1024 lines, plus shared input limits. Validate S0/S1/S2/S3/S5/S6/S7/S8/S9 count, address width and ones-complement checksum. This profile uses one consistent S1/S2/S3 data width, optional leading S0 and one optional count, then matching final termination. Reject overlaps; return sparse metadata only. No device, firmware execution or flashing. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [srecord.sourceforge.net](https://srecord.sourceforge.net/man/man5/srec_motorola.5.html). No endorsement is implied.

Example input:

```json
{
  "text": "S107001001020304DE\nS9030010EC"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/dataBytes": 4,
  "/entryAddress": 16,
  "/segments": [
    {
      "address": 16,
      "hex": "01020304"
    }
  ],
  "/dataRecordCount": 1
}
```

## TLS Record Framing Inspector API

USD 3.00 per job.

Split supplied TLS outer records and inspect content type, legacy version and declared payload lengths. Outer TLS record framing only: content types20 through23, legacy versions0301 through0303, complete5-byte headers and bodies, at most256 records/64KiB plus shared input limits. Plaintext bodies at most16384 bytes and application-data ciphertext bodies at most16640. No decryption, authentication, handshake/session validation or security assessment. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.rfc-editor.org](https://www.rfc-editor.org/rfc/rfc8446). No endorsement is implied.

Example input:

```json
{
  "hex": "1703030003aabbcc"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/records/0/contentType": 23,
  "/records/0/legacyVersion": "0303",
  "/records/0/length": 3,
  "/records/0/payloadHex": "aabbcc",
  "/recordCount": 1
}
```

## Protobuf Wire Field Inspector API

USD 3.00 per job.

Inspect raw protobuf fields with wire types0,1,2,5 without needing a message schema. 64KiB,<=1024 fields; bounded10-byte varints and legal field numbers; no groups, schema names, implicit string/nesting inference or required-field compatibility claims. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [protobuf.dev](https://protobuf.dev/programming-guides/encoding/). No endorsement is implied.

Example input:

```json
{
  "hex": "089601120141"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/fields/0/number": 1,
  "/fields/0/wireType": 0,
  "/fields/0/unsigned": "150",
  "/fields/1/number": 2,
  "/fields/1/wireType": 2,
  "/fields/1/dataHex": "41",
  "/fieldCount": 2
}
```

## Weibull Quantile Calibration

USD 19.00 per job.

Calibrate two-parameter Weibull shape and scale from supplied positive time quantiles. Linear fit log(-log(1-F)) versus log(time), no location parameter. Supplied quantiles are assumptions; no inferred lifetime qualification or certified prediction. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.itl.nist.gov](https://www.itl.nist.gov/div898/handbook/apr/section1/apr162.htm). No endorsement is implied.

Example input:

```json
{
  "times": [
    1,
    2
  ],
  "failureProbabilities": [
    0.6321205588285577,
    0.9816843611112658
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/shape": 2,
  "/scale": 1,
  "/survivalAtTime1": 0.36787944117144233
}
```

## Lognormal Lifetime Fit Report

USD 19.00 per job.

Fit uncensored positive lifetimes on log scale and report model median and mean. Complete uncensored observations, population-denominator MLE for log spread; tiny fixture is mathematical only, not adequate statistical validation. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.itl.nist.gov](https://www.itl.nist.gov/div898/handbook/apr/section1/apr164.htm). No endorsement is implied.

Example input:

```json
{
  "lifetimes": [
    1,
    7.38905609893065
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/logMean": 1,
  "/logSdMle": 1,
  "/median": 2.718281828459045,
  "/modelMean": 4.4816890703380645
}
```

## Arrhenius Lifetime Acceleration Scenario

USD 19.00 per job.

Calculate thermal acceleration from caller-supplied activation temperature and absolute test/use temperatures. Activation temperature means Ea/k. Same failure mechanism must hold across stresses; no physical test execution or certified product lifetime. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.itl.nist.gov](https://www.itl.nist.gov/div898/handbook/apr/section1/apr15.htm). No endorsement is implied.

Example input:

```json
{
  "activationTemperatureKelvin": 6000,
  "useKelvin": 300,
  "testKelvin": 400,
  "testHours": 10
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/logAccelerationFactor": 5,
  "/accelerationFactor": 148.4131591025766,
  "/equivalentUseHours": 1484.131591025766
}
```

## Miner Fatigue Damage Scenario

USD 19.00 per job.

Sum caller-provided cycle fractions across load regimes under linear cumulative damage. Caller-supplied cycle counts and positive S-N assumptions; linear Miner model ignores load ordering. Remaining fraction is clamped to zero when damage exceeds one. A scenario only, no safe-life or inspection certification. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [tfaws.nasa.gov](https://tfaws.nasa.gov/wp-content/uploads/TFAWS19-ID-11-Paper.pdf). No endorsement is implied.

Example input:

```json
{
  "regimes": [
    {
      "cycles": 100,
      "assumedCyclesToFailure": 1000
    },
    {
      "cycles": 200,
      "assumedCyclesToFailure": 1000
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/damageFractions": [
    0.1,
    0.2
  ],
  "/totalDamage": 0.3,
  "/remainingLinearFraction": 0.7
}
```

## Normal Stress Strength Interference

USD 19.00 per job.

Calculate the probability a normal strength variable exceeds an independent normal load variable. Independent normal assumptions and consistent units; probability model only, no structural or safety approval. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [onlinelibrary.wiley.com](https://onlinelibrary.wiley.com/doi/abs/10.1002/9781118445112.stat04243). No endorsement is implied.

Example input:

```json
{
  "strengthMean": 100,
  "strengthSd": 6,
  "loadMean": 90,
  "loadSd": 8
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/differenceMean": 10,
  "/differenceSd": 10,
  "/z": 1,
  "/strengthExceedsLoadProbability": 0.8413447460685429
}
```

## Duane Growth Plot Fit

USD 19.00 per job.

Fit cumulative MTBF against cumulative test time on log-log axes to expose a repair trend. Positive cumulative counts and increasing time; trend fit does not validate the NHPP model or project future gains automatically. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.itl.nist.gov](https://www.itl.nist.gov/div898/handbook/apr/section2/apr223.htm). No endorsement is implied.

Example input:

```json
{
  "times": [
    1,
    4,
    9
  ],
  "cumulativeFailures": [
    1,
    2,
    3
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/cumulativeMtbf": [
    1,
    2,
    3
  ],
  "/logLogSlope": 0.5,
  "/logLogIntercept": 0
}
```

## Censored Exposure Rate Fit

USD 19.00 per job.

Estimate a constant event rate from failures and right-censored exposure rather than treating censored units as failures. Non-informative right censoring and constant hazard; distinct from existing survival evaluation with an already supplied rate. Zero failures yields rate0 and unknown finite mean, not proven reliability. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.itl.nist.gov](https://www.itl.nist.gov/div898/handbook/apr/section4/apr451.htm). No endorsement is implied.

Example input:

```json
{
  "failedLifetimes": [
    10,
    20
  ],
  "rightCensoredExposure": [
    30,
    40
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/failureCount": 2,
  "/totalExposure": 100,
  "/rateMle": 0.02,
  "/meanLifeMle": 50
}
```

## Shared Event Fault Tree Scenario

USD 19.00 per job.

Enumerate a bounded Boolean event tree with repeated basic events and calculate exact top-event probability. Independent unique basic events, bounded truth-table enumeration; repeated A is one event. This shared-event logic differs materially from independent series/parallel branch multiplication. No safety certification. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [extapps.ksc.nasa.gov](https://extapps.ksc.nasa.gov/reliability/Documents/Fault_Tree_Handbook_with_Aerospace_Applications_August_2002.pdf). No endorsement is implied.

Example input:

```json
{
  "probabilities": {
    "A": 0.1,
    "B": 0.2,
    "C": 0.3
  },
  "tree": {
    "or": [
      {
        "and": [
          "A",
          "B"
        ]
      },
      {
        "and": [
          "A",
          "C"
        ]
      }
    ]
  }
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/minimalCutSets": [
    [
      "A",
      "B"
    ],
    [
      "A",
      "C"
    ]
  ],
  "/topEventProbability": 0.044,
  "/assignmentsEvaluated": 8
}
```

## Discrete Age Replacement Comparison

USD 19.00 per job.

Compare long-run renewal cost rates for caller-chosen preventive replacement ages under a discrete lifetime model. A failure at exactly the replacement age incurs failure cost; zero replacement downtime, IID new units. Compare supplied ages only, no maintenance instruction. Accepted probability masses within the stated unit-sum tolerance are normalized before calculation. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [repository.up.ac.za](https://repository.up.ac.za/bitstreams/503964e7-6def-43da-ae2b-b38841b93a77/download). No endorsement is implied.

Example input:

```json
{
  "lifetimes": [
    1,
    3
  ],
  "probabilities": [
    0.2,
    0.8
  ],
  "replacementAges": [
    2,
    4
  ],
  "preventiveCost": 1,
  "failureCost": 5
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/scenarios/0/expectedCycleLength": 1.8,
  "/scenarios/0/expectedCycleCost": 1.8,
  "/scenarios/0/costRate": 1,
  "/scenarios/1/costRate": 1.9230769230769231,
  "/lowestCostAge": 2
}
```

## Laplace Repair Trend Evidence

USD 19.00 per job.

Evaluate whether repair event epochs concentrate early or late within a fixed observation window. Time-censored fixed window; statistic=sqrt(12r)*(meanEpoch/end-0.5). No automatic improve/degrade significance verdict or live monitoring. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.itl.nist.gov](https://www.itl.nist.gov/div898/software/dataplot/refman1/auxillar/trentest.htm). No endorsement is implied.

Example input:

```json
{
  "repairEpochs": [
    1,
    2,
    3
  ],
  "observationEnd": 8
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/repairCount": 3,
  "/meanRepairEpoch": 2,
  "/laplaceStatistic": -1.5
}
```

## Natural Cubic Spline Evaluation API

USD 3.00 per job.

Interpolate scalar knots using a natural cubic spline with zero endpoint curvature. 2..128 strictly increasing finite x knots; queries inside knot domain only; natural boundary condition explicit. Approximate arithmetic; singular/nonfinite results reject. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.CubicSpline.html). No endorsement is implied.

Example input:

```json
{
  "x": [
    0,
    1,
    2
  ],
  "y": [
    0,
    1,
    0
  ],
  "queries": [
    0,
    0.5,
    1,
    1.5,
    2
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/values": [
    0,
    0.6875,
    1,
    0.6875,
    0
  ],
  "/secondDerivatives": [
    0,
    -3,
    0
  ]
}
```

## Polynomial Calculus Profile API

USD 3.00 per job.

Differentiate and integrate a polynomial represented by ascending coefficients. Degree<=64; finite bounded coefficients and limits. Antiderivative constant zero; normalize trailing zeros and reject nonfinite intermediates. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [numpy.org](https://numpy.org/doc/stable/reference/routines.polynomials.polynomial.html). No endorsement is implied.

Example input:

```json
{
  "coefficients": [
    1,
    -2,
    3
  ],
  "lower": 0,
  "upper": 2
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/derivative": [
    -2,
    6
  ],
  "/antiderivative": [
    0,
    1,
    -1,
    1
  ],
  "/definiteIntegral": 6
}
```

## Reduced QR Factorization API

USD 3.00 per job.

Factor a full-column-rank real matrix into orthonormal columns and upper triangular R. Modified Gram-Schmidt with a second orthogonalization pass, positive R diagonal and reconstruction residual. m>=n and both dimensions at most16. Full column rank is required at 1e-10 times maximum input magnitude; reject rank deficiency instead of silently dropping columns. Approximate factorization. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [numpy.org](https://numpy.org/doc/stable/reference/generated/numpy.linalg.qr.html). No endorsement is implied.

Example input:

```json
{
  "matrix": [
    [
      3,
      0
    ],
    [
      4,
      5
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/q": [
    [
      0.6,
      -0.8
    ],
    [
      0.8,
      0.6
    ]
  ],
  "/r": [
    [
      5,
      4
    ],
    [
      0,
      3
    ]
  ],
  "/rank": 2
}
```

## Positive Definite Cholesky API

USD 3.00 per job.

Compute a lower triangular square root of a real symmetric positive definite matrix. Real square matrix at most16, exactly symmetric supplied entries, positive pivots greater than 1e-12 times maximum input magnitude. No repair of indefinite inputs. Reconstructed residual and log determinant included; determinant outside finite supported range is null. Approximate arithmetic. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [numpy.org](https://numpy.org/doc/stable/reference/generated/numpy.linalg.cholesky.html). No endorsement is implied.

Example input:

```json
{
  "matrix": [
    [
      4,
      2
    ],
    [
      2,
      5
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/lower": [
    [
      2,
      0
    ],
    [
      1,
      2
    ]
  ],
  "/determinant": 16
}
```

## Symmetric Eigenvalue Spectrum API

USD 3.00 per job.

Compute the sorted real eigenvalues of a bounded symmetric matrix by Jacobi rotations. Jacobi rotations on an exactly symmetric supplied real square matrix, size at most12. At most5000 rotations, off-diagonal tolerance 1e-12 times maximum magnitude; nonconvergence rejects. Sorted approximate eigenvalues, trace and determinant; out-of-range determinant is null. No unique eigenvector or conditioning claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [numpy.org](https://numpy.org/doc/stable/reference/generated/numpy.linalg.eigh.html). No endorsement is implied.

Example input:

```json
{
  "matrix": [
    [
      2,
      1
    ],
    [
      1,
      2
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/eigenvalues": [
    1,
    3
  ],
  "/trace": 4,
  "/determinant": 3
}
```

## Chebyshev First Kind Table API

USD 3.00 per job.

Evaluate T_0 through T_n by their three-term recurrence. Degree 0..256 and x in [-1,1]. T0=1,T1=x,Tn=2*x*Tn-1-Tn-2; finite approximate arithmetic. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [dlmf.nist.gov](https://dlmf.nist.gov/18.5). No endorsement is implied.

Example input:

```json
{
  "degree": 4,
  "x": 0.5
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/values": [
    1,
    0.5,
    -0.5,
    -1,
    -0.5
  ],
  "/value": -0.5
}
```

## Integer Order Bessel J API

USD 3.00 per job.

Evaluate first-kind Bessel J for a bounded nonnegative integer order and real argument. Order 0..16, |x|<=10. Convergent defining series with bounded terms and cancellation-aware convergence; target absolute error 1e-10, no large-argument claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [dlmf.nist.gov](https://dlmf.nist.gov/10.2). No endorsement is implied.

Example input:

```json
{
  "order": 0,
  "x": 1
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/value": 0.765197686558
}
```

## Positive Log Gamma API

USD 3.00 per job.

Evaluate log Gamma for positive real inputs without factorial overflow. Positive real log Gamma using the nine-coefficient g=7 Lanczos approximation and reflection below0.5. Inputs1e-6 through1e6. Numerical target scales as 1e-10*max(1,abs(reference value)); outputs retain twelve significant digits. No negative or complex-domain support. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [dlmf.nist.gov](https://dlmf.nist.gov/5.4). No endorsement is implied.

Example input:

```json
{
  "values": [
    1,
    2,
    5
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/values": [
    0,
    0,
    3.17805383035
  ]
}
```

## Gauss Legendre Quadrature Rule API

USD 3.00 per job.

Generate nodes and weights for integrating over [-1,1]. Order 1..32. Bound Newton iterations for Legendre zeros; sorted nodes, positive symmetric weights, approximate accuracy target1e-10; no arbitrary function execution. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [dlmf.nist.gov](https://dlmf.nist.gov/3.5). No endorsement is implied.

Example input:

```json
{
  "order": 3
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/nodes": [
    -0.774596669241,
    0,
    0.774596669241
  ],
  "/weights": [
    0.555555555556,
    0.888888888889,
    0.555555555556
  ],
  "/weightSum": 2
}
```

## Linear ODE RK4 Rehearsal API

USD 3.00 per job.

Integrate y'=a*y+b*t+c using classical fixed-step fourth-order Runge Kutta. Steps1..4096, positive finite step; fixed classical RK4 (not MATLAB ode45), no expressions or eval, no adaptive-error guarantee; reject overflow. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [persson.berkeley.edu](https://persson.berkeley.edu/Programming_for_Mathematical_Applications/content/Differential_Equations/Chapter_Intro.html). No endorsement is implied.

Example input:

```json
{
  "a": 0,
  "b": 1,
  "c": 0,
  "t0": 0,
  "y0": 0,
  "step": 1,
  "steps": 2
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/times": [
    0,
    1,
    2
  ],
  "/values": [
    0,
    0.5,
    2
  ],
  "/finalValue": 2
}
```

## Zero One Knapsack Optimum API

USD 3.00 per job.

Select a maximum-value subset under an integer capacity. At most 64 items; capacity<=4096 and positive integer weights, nonnegative safe integer values. Each item once; deterministic lexicographic selected-index ties. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.princeton.edu](https://www.cs.princeton.edu/courses/archive/spring13/cos423/lectures/06DynamicProgrammingI.pdf). No endorsement is implied.

Example input:

```json
{
  "weights": [
    2,
    3,
    4
  ],
  "values": [
    3,
    4,
    5
  ],
  "capacity": 5
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/maximumValue": 7,
  "/totalWeight": 5,
  "/selected": [
    0,
    1
  ]
}
```

## Unbounded Coin Change Profile API

USD 3.00 per job.

Find minimum coin count and exact unordered denomination combinations for a target. At most 32 distinct positive denominations; target<=4096. Unlimited supply; combination order ignored; impossible minimum is null. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [ocw.mit.edu](https://ocw.mit.edu/courses/6-046j-design-and-analysis-of-algorithms-spring-2015/d187472426117c2ebec700a22c209b3f_MIT6_046JS15_Recitation5.pdf). No endorsement is implied.

Example input:

```json
{
  "denominations": [
    1,
    3,
    4
  ],
  "target": 6
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/minimumCoins": 2,
  "/coins": [
    3,
    3
  ],
  "/combinationCount": "4"
}
```

## Subset Sum Exact Witness API

USD 3.00 per job.

Determine whether a nonnegative integer target is a subset sum and return a witness. At most 64 nonnegative safe integers; target<=8192. Empty subset allowed for zero; select lexicographically smallest index-vector witness. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.ocw.mit.edu](https://www.ocw.mit.edu/courses/6-006-introduction-to-algorithms-spring-2020/video_galleries/lecture-videos/). No endorsement is implied.

Example input:

```json
{
  "values": [
    3,
    5,
    7
  ],
  "target": 10
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/reachable": true,
  "/indices": [
    0,
    2
  ],
  "/sum": 10
}
```

## Weighted Interval Selection API

USD 3.00 per job.

Choose maximum total value of nonoverlapping half-open intervals. At most 256 intervals with start<end and nonnegative integer values. Adjacent endpoints compatible; stable selected-index ties. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.princeton.edu](https://www.cs.princeton.edu/courses/archive/spring13/cos423/lectures/06DynamicProgrammingI.pdf). No endorsement is implied.

Example input:

```json
{
  "intervals": [
    {
      "start": 0,
      "end": 2,
      "value": 4
    },
    {
      "start": 1,
      "end": 3,
      "value": 7
    },
    {
      "start": 2,
      "end": 4,
      "value": 4
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/maximumValue": 8,
  "/selected": [
    0,
    2
  ]
}
```

## Matrix Chain Parenthesization API

USD 3.00 per job.

Find the multiplication order requiring the fewest scalar products. 2..65 positive dimensions <=1000000; exact BigInt product/count. Ties choose lowest split index; matrices themselves are not multiplied. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [ocw.mit.edu](https://ocw.mit.edu/courses/6-006-introduction-to-algorithms-spring-2008/resources/lec21/). No endorsement is implied.

Example input:

```json
{
  "dimensions": [
    10,
    30,
    5,
    60
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/minimumMultiplications": "4500",
  "/parenthesization": "((A1A2)A3)"
}
```

## Minimum Cost Square Assignment API

USD 3.00 per job.

Assign each row to one distinct column with minimum total declared cost. Square n<=16 safe integer matrix; subset DP or Hungarian with stable lexicographic column-vector ties. No unmatched rows. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [algs4.cs.princeton.edu](https://algs4.cs.princeton.edu/code/javadoc/edu/princeton/cs/algs4/AssignmentProblem.html). No endorsement is implied.

Example input:

```json
{
  "costs": [
    [
      4,
      1,
      3
    ],
    [
      2,
      0,
      5
    ],
    [
      3,
      2,
      2
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/minimumCost": 5,
  "/columnsByRow": [
    1,
    0,
    2
  ]
}
```

## Bounded Exact Set Cover API

USD 3.00 per job.

Find the least-cost selected sets covering an explicit small universe. Universe<=16 unique tokens; sets<=24; nonnegative integer costs. Exact bitmask DP, no greedy optimality claim; infeasible cost null. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [pubsonline.informs.org](https://pubsonline.informs.org/doi/10.1287/opre.25.5.760). No endorsement is implied.

Example input:

```json
{
  "universe": [
    "a",
    "b",
    "c"
  ],
  "sets": [
    {
      "members": [
        "a",
        "b"
      ],
      "cost": 3
    },
    {
      "members": [
        "b",
        "c"
      ],
      "cost": 2
    },
    {
      "members": [
        "a",
        "c"
      ],
      "cost": 2
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/feasible": true,
  "/minimumCost": 4,
  "/selected": [
    1,
    2
  ]
}
```

## Bounded CNF Satisfiability API

USD 3.00 per job.

Decide a small Boolean CNF formula and return a satisfying assignment. At most 16 Boolean variables, 128 clauses and 32 literals per clause; signed nonzero 1-based literals. DPLL uses unit propagation, fixed variable order and false-before-true choices. Reject more than four million literal checks as a computation-profile limit before checkout, never as an unsatisfiability result. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.cmu.edu](https://www.cs.cmu.edu/~15414/s25/lectures/16-dpll.pdf). No endorsement is implied.

Example input:

```json
{
  "variables": 3,
  "clauses": [
    [
      1
    ],
    [
      -1,
      2
    ],
    [
      -2,
      3
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/satisfiable": true,
  "/assignment": [
    true,
    true,
    true
  ]
}
```

## Exact Small Hamiltonian Tour API

USD 3.00 per job.

Find a minimum-cost closed tour visiting each matrix vertex once. 2..12 vertices, finite nonnegative integer complete costs. Held-Karp or bounded exact enumeration; stable lexicographic tour ties; supplied costs only. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [xlinux.nist.gov](https://xlinux.nist.gov/dads/HTML/travelingSalesman.html). No endorsement is implied.

Example input:

```json
{
  "costs": [
    [
      0,
      2,
      9
    ],
    [
      2,
      0,
      3
    ],
    [
      9,
      3,
      0
    ]
  ],
  "start": 0
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/minimumCost": 14,
  "/tour": [
    0,
    1,
    2,
    0
  ]
}
```

## Optimal Static Search Tree API

USD 3.00 per job.

Optimize a static BST for supplied successful-search frequencies. 1..64 strictly increasing safe-integer keys; nonnegative integer frequencies. Successful searches only, root costs one comparison; ties lowest root index. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [ocw.mit.edu](https://ocw.mit.edu/courses/6-046j-design-and-analysis-of-algorithms-spring-2015/828e034d5ace10df79e57397124684ca_Tw1k46ywN6E.pdf). No endorsement is implied.

Example input:

```json
{
  "keys": [
    10,
    20,
    30
  ],
  "frequencies": [
    1,
    10,
    1
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/weightedComparisons": "14",
  "/rootIndex": 1,
  "/preorder": [
    20,
    10,
    30
  ]
}
```

## Moist Air State Scenario

USD 19.00 per job.

Calculate humidity ratio, relative humidity and approximate moist-air enthalpy from supplied thermodynamic state evidence. Caller supplies saturation pressure; vapor pressure may equal saturation but must remain below total pressure. Ideal moist-air W=0.62198*Pv/(P-Pv), h=1.006*T+W*(2501+1.86*T). Supplied-data approximation, no comfort, health or HVAC certification. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [energyplus.readthedocs.io](https://energyplus.readthedocs.io/en/latest/guides/module-developer/7.14-psychrometric-services.html). No endorsement is implied.

Example input:

```json
{
  "dryBulbC": 20,
  "vaporPressurePa": 1000,
  "saturationPressurePa": 2000,
  "totalPressurePa": 63198
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/humidityRatioKgPerKgDryAir": 0.01,
  "/relativeHumidity": 0.5,
  "/enthalpyKjPerKgDryAir": 45.502
}
```

## Heat Exchanger Log Mean Scenario

USD 19.00 per job.

Calculate counterflow terminal temperature differences, their logarithmic mean and UA-based heat transfer. Positive terminal differences, continuous equal-difference limit; ideal counterflow, no fouling or correction factor inferred. No equipment sizing approval. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.energy.gov](https://www.energy.gov/documents/doe-hdbk-1012-92vol2). No endorsement is implied.

Example input:

```json
{
  "hotInC": 80,
  "hotOutC": 50,
  "coldInC": 30,
  "coldOutC": 40,
  "uaWattsPerKelvin": 100
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/terminalDifferencesK": [
    40,
    20
  ],
  "/logMeanDifferenceK": 28.85390081777927,
  "/heatTransferWatts": 2885.390081777927
}
```

## Pipe Friction Pressure Scenario

USD 19.00 per job.

Separate Darcy-Weisbach straight-pipe and supplied fitting pressure losses. Incompressible steady full-pipe flow, supplied Darcy factor (not Fanning), no factor/rating inferred. Distinct from existing pump energy at supplied head; no pressure-system certification. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [nepis.epa.gov](https://nepis.epa.gov/Exe/ZyPURL.cgi?Dockey=P10113EM.txt). No endorsement is implied.

Example input:

```json
{
  "darcyFrictionFactor": 0.02,
  "lengthM": 10,
  "diameterM": 0.1,
  "densityKgM3": 1000,
  "velocityMS": 2,
  "minorLossK": 1
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/straightPipeLossPa": 4000,
  "/minorLossPa": 2000,
  "/totalLossPa": 6000
}
```

## Stokes Particle Settling Scenario

USD 19.00 per job.

Calculate ideal spherical-particle terminal settling speed and check the implied Reynolds number. Ideal dilute rigid spheres, v=(rhoParticle-rhoFluid)*g*d²/(18*mu); signed velocity permits upward buoyancy. Reynolds number uses absolute speed; the reported Re<1 condition is only a regime indicator, not validation of the creeping-flow approximation or equipment suitability. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [nepis.epa.gov](https://nepis.epa.gov/Exe/ZyPURL.cgi?Dockey=300051EN.TXT). No endorsement is implied.

Example input:

```json
{
  "particleDensityKgM3": 2000,
  "fluidDensityKgM3": 1000,
  "dynamicViscosityPaS": 0.001,
  "diameterM": 0.0001,
  "gravityMS2": 9.81
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/settlingVelocityMS": 0.00545,
  "/particleReynolds": 0.545
}
```

## Ideal Gas Inventory Scenario

USD 19.00 per job.

Estimate gas amount and mass from absolute pressure, free volume, temperature and molar mass. PV=nRT, R=8.31446261815324 J/(mol K); absolute positive P/T. Ideal-gas approximation excludes real-gas pressure effects and vessel operating/safety advice. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www1.grc.nasa.gov](https://www1.grc.nasa.gov/beginners-guide-to-aeronautics/equation-of-state/). No endorsement is implied.

Example input:

```json
{
  "absolutePressurePa": 100000,
  "volumeM3": 1,
  "temperatureK": 300,
  "molarMassKgMol": 0.028
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/moles": 40.09078501424201,
  "/massKg": 1.1225419803987762
}
```

## Adiabatic Batch Mixing Scenario

USD 19.00 per job.

Calculate equilibrium temperature and exchanged sensible heat for supplied compatible material batches. Constant heat capacities, no phase change, reaction, work or loss; supplied substances assumed compatible. Energy balance differs from existing material mass-balance reconciliation. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [ocw.mit.edu](https://ocw.mit.edu/courses/3-020-thermodynamics-of-materials-spring-2021/resources/mit3_020s21_lecture_03_1080p_mp4/). No endorsement is implied.

Example input:

```json
{
  "batches": [
    {
      "massKg": 2,
      "heatCapacityKjKgK": 1,
      "temperatureC": 20
    },
    {
      "massKg": 1,
      "heatCapacityKjKgK": 2,
      "temperatureC": 80
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/equilibriumC": 50,
  "/heatCapacityTotalKjK": 4,
  "/batchHeatChangesKj": [
    60,
    -60
  ]
}
```

## Rotary Drive Speed Torque Scenario

USD 19.00 per job.

Translate a supplied ideal pulley ratio into driven speed and torque at a stated delivered mechanical power. Ideal no-slip ratio and delivered shaft power, positive speed; no motor efficiency, belt tension or component suitability claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.energy.gov](https://www.energy.gov/sites/default/files/2014/04/f15/amo_motors_sourcebook_web.pdf). No endorsement is implied.

Example input:

```json
{
  "driverRpm": 1800,
  "driverDiameterMm": 100,
  "drivenDiameterMm": 300,
  "deliveredPowerWatts": 2000
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/drivenRpm": 600,
  "/drivenAngularSpeedRadS": 62.83185307179586,
  "/drivenTorqueNm": 31.830988618379067
}
```

## Incoherent Acoustic Source Sum

USD 19.00 per job.

Combine compatible independently measured logarithmic sound-energy levels at one observation point. Same reference, weighting, bandwidth and observation point; incoherent simultaneous sources only. No exposure-duration, hearing-protection or regulatory-compliance verdict. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.osha.gov](https://www.osha.gov/otm/section-3-health-hazards/chapter-5). No endorsement is implied.

Example input:

```json
{
  "levelsDb": [
    60,
    60
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/combinedLevelDb": 63.01029995663981,
  "/increaseAboveLargestDb": 3.010299956639812
}
```

## Vibration Crest Profile Report

USD 19.00 per job.

Calculate RMS, absolute peak, crest factor and peak-to-peak spread from supplied equally spaced vibration samples. Equally spaced raw numeric samples with caller-managed units and provenance; DC remains included. All-zero samples produce null crest factor. No frequency diagnosis, machinery fault inference or safe operating threshold. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.mathworks.com](https://www.mathworks.com/help/signal/descriptive-statistics.html). No endorsement is implied.

Example input:

```json
{
  "samples": [
    0,
    2,
    0,
    -2
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/rms": 1.4142135623730951,
  "/absolutePeak": 2,
  "/crestFactor": 1.4142135623730951,
  "/peakToPeak": 4
}
```

## Steady Diffusion Flux Scenario

USD 19.00 per job.

Calculate one-dimensional Fick flux through a uniform layer and total molar transfer rate. Steady linear gradient, constant positive diffusivity and thickness, no convection/reaction. A supplied-data process scenario, not hazardous-material containment or safety approval. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [web.mit.edu](https://web.mit.edu/1.061/www/diffuse/theory.htm). No endorsement is implied.

Example input:

```json
{
  "diffusivityM2S": 1e-9,
  "leftConcentrationMolM3": 1000,
  "rightConcentrationMolM3": 0,
  "thicknessM": 0.001,
  "areaM2": 2
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/concentrationGradientMolM4": -1000000,
  "/fluxMolM2S": 0.001,
  "/molarTransferRateMolS": 0.002
}
```

## Unequal Bernoulli Count Scenario

USD 19.00 per job.

Compute the full event-count distribution for independent trials with different supplied probabilities. Bounded dynamic program; independence and caller probabilities are assumptions. Not an observed sales-pipeline weighted-value total. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.poisson_binom.html). No endorsement is implied.

Example input:

```json
{
  "probabilities": [
    0.2,
    0.5
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/countProbabilities": [
    0.4,
    0.5,
    0.1
  ],
  "/mean": 0.7,
  "/variance": 0.41
}
```

## Beta Binomial Predictive Scenario

USD 19.00 per job.

Update a supplied beta prior with binary observations and calculate exact predictive event-count probabilities. Positive prior alpha/beta<=one million, nonnegative observed successes/failures<=one million each, future horizon0 through128. A stable log-ratio recurrence normalizes the predictive PMF. Exchangeable Bernoulli assumptions and prior remain supplied, not empirically calibrated future guarantees. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.betabinom.html). No endorsement is implied.

Example input:

```json
{
  "priorAlpha": 1,
  "priorBeta": 1,
  "successes": 1,
  "failures": 1,
  "futureTrials": 2
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/posteriorAlpha": 2,
  "/posteriorBeta": 2,
  "/predictiveProbabilities": [
    0.3,
    0.4,
    0.3
  ],
  "/predictiveMean": 1,
  "/predictiveVariance": 0.6
}
```

## Absorbing Workflow Outcome Scenario

USD 19.00 per job.

Solve expected transient-stage visits and terminal outcome probabilities from a supplied absorbing Markov chain. Two through16 supplied states, square stochastic rows (sum tolerance1e-12, accepted rows normalized), explicit exact self-loop absorbing states. Every transient state must reach an absorbing state. Diagonal escape mass uses summed off-diagonal probabilities to avoid subtracting near1. Partial-pivot solve rejects pivots below1e-10 and expected time above10^10. Includes current transient visit; an absorbing start has zero steps. Hypothetical stationary chain, not observed workflow qualification. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [lips.cs.princeton.edu](https://lips.cs.princeton.edu/the-fundamental-matrix-of-a-finite-markov-chain/). No endorsement is implied.

Example input:

```json
{
  "states": [
    "work",
    "done",
    "abandon"
  ],
  "transition": [
    [
      0.5,
      0.3,
      0.2
    ],
    [
      0,
      1,
      0
    ],
    [
      0,
      0,
      1
    ]
  ],
  "start": "work"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/expectedStepsToAbsorption": 2,
  "/absorptionProbabilities/done": 0.6,
  "/absorptionProbabilities/abandon": 0.4
}
```

## Branching Cascade Scenario

USD 19.00 per job.

Rehearse expected cascade size and finite-generation extinction under a supplied offspring distribution. Independent identical offspring, discrete generations and bounded horizon; useful for hypothetical referral or rework cascades, not epidemic or safety prediction. Accepted probability masses within the stated unit-sum tolerance are normalized before calculation. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [ocw.mit.edu](https://ocw.mit.edu/courses/14-15j-networks-spring-2018/3c4dd8f345d41e28fb246ee18fcb4ba5_MIT14_15JS18_lec21.pdf). No endorsement is implied.

Example input:

```json
{
  "offspringProbabilities": [
    0.5,
    0,
    0.5
  ],
  "initialUnits": 1,
  "generations": 2
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/offspringMean": 1,
  "/expectedPopulationByGeneration": [
    1,
    1,
    1
  ],
  "/extinctionProbabilityByGeneration": [
    0,
    0.5,
    0.625
  ]
}
```

## Coupon Coverage Effort Scenario

USD 19.00 per job.

Estimate repeated observation effort needed to encounter every equally likely category. One through20 uniformly likely categories and0 through10000 independent replacement draws. Expected completion n*H_n; an occupancy dynamic program computes coverage without cancellation-prone alternating sums. This assumes no rare-category bias and guarantees no real-world observation completeness. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [courses.csail.mit.edu](https://courses.csail.mit.edu/6.042/past-devel/archive/spring05/notes/prob_exp2.pdf). No endorsement is implied.

Example input:

```json
{
  "categoryCount": 3,
  "draws": 3
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/expectedDrawsToAll": 5.5,
  "/probabilityAllSeenByDraws": 0.2222222222222222,
  "/expectedDistinctSeen": 2.111111111111111
}
```

## Uniform Collision Occupancy Scenario

USD 19.00 per job.

Quantify duplicate-bucket probability and expected colliding pairs for a hypothetical uniform assignment. Uniform independent assignment only; not a cryptographic security guarantee or empirical duplicate detector. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [web.stanford.edu](https://web.stanford.edu/class/stats60/lectures/11-lecture-coincidences.html). No endorsement is implied.

Example input:

```json
{
  "bucketCount": 10,
  "assignments": 3
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/noCollisionProbability": 0.72,
  "/collisionProbability": 0.28,
  "/expectedCollidingPairs": 0.3
}
```

## Renewal Inspection Wait Scenario

USD 19.00 per job.

Compare event-average intervals with the longer intervals seen at random inspection times. Stationary continuous-time IID renewal model, finite second moment; residual E[X^2]/(2E[X]). Not observed ticket waiting-time analysis. Accepted probability masses within the stated unit-sum tolerance are normalized before calculation. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [ocw.mit.edu](https://ocw.mit.edu/courses/6-262-discrete-stochastic-processes-spring-2011/b9d25a138a53641f9b804920fcfd3a54_QWHtRR1jMEQ.pdf). No endorsement is implied.

Example input:

```json
{
  "durations": [
    2,
    6
  ],
  "probabilities": [
    0.5,
    0.5
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/meanInterval": 4,
  "/secondMoment": 20,
  "/meanInspectedInterval": 5,
  "/meanResidualWait": 2.5
}
```

## Negative Binomial Effort Scenario

USD 19.00 per job.

Model total independent trial effort required to accumulate a stated number of successes. One through128 required successes, independent fixed p in[10^-6,1], trial budget0 through4096. Count total trials including successes. A capped binomial-state DP gives completion probability; no live collection, intervention or guaranteed campaign result. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.nbinom.html). No endorsement is implied.

Example input:

```json
{
  "requiredSuccesses": 2,
  "successProbability": 0.5,
  "trialBudget": 3
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/expectedTrials": 4,
  "/trialVariance": 4,
  "/completionProbabilityWithinBudget": 0.5
}
```

## Parallel Geometric Completion Scenario

USD 19.00 per job.

Calculate the time until every independent repeated-trial workstream has succeeded at least once. One through20 IID geometric workstreams, p in[10^-6,1],0 through one million rounds. First completion is round1. A nonnegative expected-remaining-state recurrence avoids cancellation in alternating inclusion-exclusion. This is a repeated-trial model, not a schedule or live retry action. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.sciencedirect.com](https://www.sciencedirect.com/science/article/pii/S0167715207002040). No endorsement is implied.

Example input:

```json
{
  "workstreamCount": 2,
  "successProbability": 0.5,
  "rounds": 2
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/expectedCompletionRounds": 2.6666666666666665,
  "/probabilityCompleteByRounds": 0.5625
}
```

## Wald Sequential Evidence Replay

USD 19.00 per job.

Replay predeclared binary likelihood-ratio boundaries against a supplied observation sequence. Fixed distinct Bernoulli hypotheses in[10^-6,1-10^-6], alpha/beta positive with sum<1, at most256 supplied outcomes. First crossing index is one-based; its decision is retained while final likelihood replays all supplied observations. An unrepresentable ratio is null with finite log retained. Predeclared-boundary replay only, no live sequential test or acceptance action. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [nvlpubs.nist.gov](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication500-256.pdf). No endorsement is implied.

Example input:

```json
{
  "nullProbability": 0.2,
  "alternativeProbability": 0.8,
  "alpha": 0.05,
  "beta": 0.05,
  "observations": [
    1,
    1,
    1
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/likelihoodRatio": 64,
  "/upperBoundary": 19,
  "/lowerBoundary": 0.05263157894736842,
  "/firstCrossingIndex": 3,
  "/decision": "alternative"
}
```

## Mann Whitney Group Evidence

USD 19.00 per job.

Compare independent ordinal samples through rank sums. At most eight observations per group. Exact two-sided U enumeration is returned only without pooled ties; tied data retains the statistic with null exact inference. Independence and comparable measurement scope remain caller assumptions. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.mannwhitneyu.html). No endorsement is implied.

Example input:

```json
{
  "a": [
    1,
    2
  ],
  "b": [
    3,
    4
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/uA": 0,
  "/uB": 4,
  "/twoSidedExactP": 0.3333333333333333
}
```

## Wilcoxon Paired Rank Evidence

USD 19.00 per job.

Assess supplied paired differences using signed absolute ranks. Exact zeros are excluded; exact sign enumeration is limited to sixteen nonzero observations without tied absolute differences. Symmetry is an assumption; tied or empty effective samples have null exact p. No causal conclusion. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.wilcoxon.html). No endorsement is implied.

Example input:

```json
{
  "differences": [
    1,
    2,
    3,
    4
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/positiveRankSum": 10,
  "/negativeRankSum": 0,
  "/statistic": 0,
  "/twoSidedExactP": 0.125
}
```

## Kruskal Wallis Group Evidence

USD 19.00 per job.

Compare pooled rank dispersion across three or more independent groups with average ties and tie correction. Report H and degrees of freedom only; no automatic chi-square p or significance conclusion for small groups. All-identical measurements have null H. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.kruskal.html). No endorsement is implied.

Example input:

```json
{
  "groups": [
    [
      1,
      2
    ],
    [
      3,
      4
    ],
    [
      5,
      6
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/rankSums": [
    3,
    7,
    11
  ],
  "/h": 4.571428571428571,
  "/degreesOfFreedom": 2
}
```

## Friedman Block Rank Evidence

USD 19.00 per job.

Compare three or more repeated conditions within complete blocks using average ranks and tie correction. Supplied columns must represent the same conditions in every block. Degenerate all-tied data has null statistic; no automatic practical or causal claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.friedmanchisquare.html). No endorsement is implied.

Example input:

```json
{
  "blocks": [
    [
      1,
      2,
      3
    ],
    [
      2,
      4,
      6
    ],
    [
      3,
      6,
      9
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/rankSums": [
    3,
    6,
    9
  ],
  "/statistic": 6,
  "/degreesOfFreedom": 2
}
```

## Kendall Pair Order Concordance

USD 19.00 per job.

Count concordant, discordant and separately tied observation pairs and compute Kendall tau-b. At most 128 aligned observations per series; null when the denominator is zero. Association only, without a causal or predictive claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [itl.nist.gov](https://itl.nist.gov/div898/software/dataplot/refman2/auxillar/kendell.htm). No endorsement is implied.

Example input:

```json
{
  "x": [
    1,
    2,
    3
  ],
  "y": [
    1,
    3,
    2
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/concordant": 2,
  "/discordant": 1,
  "/tauB": 0.3333333333333333
}
```

## McNemar Paired Binary Evidence

USD 19.00 per job.

Assess a supplied paired binary before/after contingency table. Exact two-sided inference uses only the discordant pairs, at most 128. Zero discordants produce null test statistics. Paired units are required; this is not an independent-sample test. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.statsmodels.org](https://www.statsmodels.org/stable/generated/statsmodels.stats.contingency_tables.mcnemar.html). No endorsement is implied.

Example input:

```json
{
  "table": [
    [
      10,
      1
    ],
    [
      5,
      10
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/discordantCount": 6,
  "/uncorrectedChiSquare": 2.6666666666666665,
  "/twoSidedExactP": 0.21875
}
```

## Cochran Repeated Binary Evidence

USD 19.00 per job.

Compare complete binary conditions observed for the same units using Cochran Q. At least three conditions. Uniform rows can make Q undefined; report null rather than inventing significance. No asymptotic p-value or improvement guarantee. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.statsmodels.org](https://www.statsmodels.org/stable/generated/statsmodels.stats.contingency_tables.cochrans_q.html). No endorsement is implied.

Example input:

```json
{
  "rows": [
    [
      1,
      0,
      0
    ],
    [
      1,
      1,
      0
    ],
    [
      1,
      0,
      1
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/columnTotals": [
    3,
    1,
    1
  ],
  "/statistic": 2.6666666666666665,
  "/degreesOfFreedom": 2
}
```

## Paired Sign Exact Evidence

USD 19.00 per job.

Assess the direction of supplied paired changes with a fair-coin exact tail, ignoring magnitudes and excluding zeros. Two-sided p is twice the smaller tail, capped at one. At most 128 differences; no nonzero differences produce null inference. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.binomtest.html). No endorsement is implied.

Example input:

```json
{
  "differences": [
    -1,
    2,
    3,
    4
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/positive": 3,
  "/negative": 1,
  "/excludedZeros": 0,
  "/twoSidedExactP": 0.625
}
```

## Kolmogorov Sample Distance Report

USD 19.00 per job.

Locate the largest right-continuous empirical distribution difference for two supplied samples, including ties. The first ascending location wins equal nonzero distances; identical distributions have null location. Descriptive D only; no continuous-null p-value. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/tutorial/stats/comparing_two_samples.html). No endorsement is implied.

Example input:

```json
{
  "a": [
    1,
    2
  ],
  "b": [
    3,
    4
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/distance": 1,
  "/location": 2,
  "/sign": 1
}
```

## Exact Label Permutation Evidence

USD 19.00 per job.

Enumerate all fixed-size label reallocations for at most eight integer-valued observations per group. The two-sided p-value uses the absolute-statistic tail: the proportion with absolute permuted mean difference at least the absolute observed difference, not twice the smaller one-sided tail. These conventions can differ for unequal group sizes. Exact integer tail comparisons avoid floating threshold ambiguity; displayed mean differences and p are numerical approximations. Exchangeable labels are assumed; no randomized simulation or causal certification. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.permutation_test.html). No endorsement is implied.

Example input:

```json
{
  "a": [
    1,
    2
  ],
  "b": [
    3,
    4
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/observedMeanDifference": -2,
  "/permutations": 6,
  "/nullDifferences": [
    -2,
    -1,
    0,
    0,
    1,
    2
  ],
  "/twoSidedExactP": 0.3333333333333333
}
```

## Theil Sen Robust Trend Report

USD 19.00 per job.

Fit a resistant straight-line trend from the median of all pairwise slopes. Bound quadratic pair generation; skip equal-x pairs. Joint intercept=median(y-slope*x); no automatic forecast or causal claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.theilslopes.html). No endorsement is implied.

Example input:

```json
{
  "x": [
    0,
    1,
    2,
    3,
    4
  ],
  "y": [
    1,
    3,
    5,
    7,
    100
  ],
  "interceptMethod": "joint"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/slope": 2,
  "/intercept": 1,
  "/validPairCount": 10
}
```

## Deming Two Axis Calibration

USD 19.00 per job.

Fit a line when both measurement axes have error with a supplied variance ratio. Constant positive known error-variance ratio, nonzero covariance; different optimization objective from existing ordinary least squares. No calibration certificate. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.itl.nist.gov](https://www.itl.nist.gov/div898/software/dataplot/refman1/auxillar/demfit.htm). No endorsement is implied.

Example input:

```json
{
  "x": [
    1,
    2,
    3
  ],
  "y": [
    2,
    3,
    7
  ],
  "errorVarianceRatioYtoX": 1
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/slope": 2.762049935181331,
  "/intercept": -1.5240998703626614,
  "/meanX": 2,
  "/meanY": 4
}
```

## Huber Robust Location Report

USD 19.00 per job.

Estimate location by solving the bounded-influence Huber score equation with a caller-set absolute cutoff. Fixed original-unit delta and bounded monotone root solver; retain all values. Returns convergence status and iterations; a nonconverged result is a diagnostic approximation, not a qualified estimate. Interpolation within the final bracket improves numerical precision. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.statsmodels.org](https://www.statsmodels.org/stable/generated/statsmodels.robust.norms.HuberT.html). No endorsement is implied.

Example input:

```json
{
  "values": [
    0,
    0,
    0,
    10
  ],
  "delta": 1,
  "tolerance": 1e-8,
  "maxIterations": 200
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/location": 0.3333333333333333,
  "/scoreSum": 0
}
```

## Hampel Local Spike Preview

USD 19.00 per job.

Flag local spikes against rolling median and scaled MAD and preview median replacement. Complete windows only, original unmodified samples in every window, scaled MAD factor 1.4826. Zero MAD flags any nonzero deviation; exact median matches remain. Preview only, never edits or removes supplied data. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.mathworks.com](https://www.mathworks.com/help/signal/ref/hampel.html). No endorsement is implied.

Example input:

```json
{
  "values": [
    0,
    1,
    9,
    2,
    3
  ],
  "radius": 2,
  "sigmaMultiplier": 3,
  "edgePolicy": "complete-windows-only"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/flaggedIndexes": [
    2
  ],
  "/replacementPreview": [
    0,
    1,
    2,
    2,
    3
  ],
  "/centerMedian": 2,
  "/centerMad": 1
}
```

## Cook Line Influence Profile

USD 19.00 per job.

Expose leverage and Cook distance for each observation in an intercept-plus-line model. Intercept-plus-line p=2, at least three observations and positive residual MSE. Leverage indistinguishable from one within 1e-12 produces null Cook distance. Influence invites investigation, never automatic removal. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.statsmodels.org](https://www.statsmodels.org/stable/generated/statsmodels.stats.outliers_influence.OLSInfluence.html). No endorsement is implied.

Example input:

```json
{
  "x": [
    0,
    1,
    2
  ],
  "y": [
    0,
    1,
    3
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/leverages": [
    0.8333333333333334,
    0.3333333333333333,
    0.8333333333333334
  ],
  "/cookDistances": [
    2.5,
    0.25,
    2.5
  ],
  "/residualMse": 0.16666666666666666
}
```

## Durbin Watson Residual Profile

USD 19.00 per job.

Measure adjacent dependence in an explicitly ordered residual sequence. Ordering must be meaningful; statistic only with no automatic critical-value inference. All-zero residuals give undefined ratio. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.statsmodels.org](https://www.statsmodels.org/stable/generated/statsmodels.stats.stattools.durbin_watson.html). No endorsement is implied.

Example input:

```json
{
  "residuals": [
    1,
    -1,
    1,
    -1
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/statistic": 3,
  "/successiveDifferenceSquares": 12,
  "/residualSquares": 4
}
```

## Breusch Pagan Variance Profile

USD 19.00 per job.

Regress squared supplied residuals on variance predictors and report the nR^2 Koenker statistic. One supplied variance predictor plus auxiliary intercept, robust Koenker nR² convention. Constant squared residuals produce null statistics; nonconstant predictor required. No automatic p-value or model repair. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.statsmodels.org](https://www.statsmodels.org/stable/generated/statsmodels.stats.diagnostic.het_breuschpagan.html). No endorsement is implied.

Example input:

```json
{
  "residuals": [
    -1,
    1,
    -2,
    2
  ],
  "variancePredictor": [
    0,
    1,
    2,
    3
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/auxiliaryRSquared": 0.8,
  "/lmStatistic": 3.2,
  "/degreesOfFreedom": 1
}
```

## Predictor Variance Inflation Report

USD 19.00 per job.

Regress each predictor on the others to quantify variance inflation from collinearity. Complete numeric observations with more rows than predictors, auxiliary intercept included. Uses inverse centered correlation matrix; normalized pivot <=1e-10 or any constant column returns null VIFs with explicit statuses, never infinity or automatic column deletion. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.statsmodels.org](https://www.statsmodels.org/stable/generated/statsmodels.stats.outliers_influence.variance_inflation_factor.html). No endorsement is implied.

Example input:

```json
{
  "predictors": [
    [
      -1,
      -1
    ],
    [
      0,
      1
    ],
    [
      1,
      0
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/correlationMatrix": [
    [
      1,
      0.5
    ],
    [
      0.5,
      1
    ]
  ],
  "/varianceInflationFactors": [
    1.3333333333333333,
    1.3333333333333333
  ]
}
```

## Grubbs Single Outlier Profile

USD 19.00 per job.

Locate the largest standardized absolute deviation under a single-outlier normal-sample model. Report G without unprovided critical-value machinery; normality and one-outlier assumptions matter. No repeated automatic deletion. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.itl.nist.gov](https://www.itl.nist.gov/div898/handbook/eda/section3/eda35h1.htm). No endorsement is implied.

Example input:

```json
{
  "values": [
    0,
    0,
    0,
    10
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/mean": 2.5,
  "/sampleSd": 5,
  "/candidateIndex": 3,
  "/gStatistic": 1.5
}
```

## Jackknife Ratio Sensitivity Report

USD 19.00 per job.

Replay leave-one-out ratio estimates to report jackknife bias and standard error. Paired independent supplied units; bounded leave-one-out ratio sensitivity. Full and deleted denominators must exceed 1e-12 times max(1,sum absolute denominators). Reports bias and standard error, no causal or forecasting claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [arxiv.org](https://arxiv.org/abs/1606.00497). No endorsement is implied.

Example input:

```json
{
  "numerators": [
    1,
    2,
    6
  ],
  "denominators": [
    1,
    1,
    2
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/ratio": 2.25,
  "/leaveOneOut": [
    2.6666666666666665,
    2.3333333333333335,
    1.5
  ],
  "/estimatedBias": -0.16666666666666666,
  "/biasCorrectedRatio": 2.4166666666666665,
  "/jackknifeStandardError": 0.693888666488711
}
```

## Neyman Stratified Sample Plan

USD 19.00 per job.

Choose continuous stratum sample sizes that minimize mean-estimator variance for a fixed sample budget. Two through32 strata with positive population and supplied positive spread, sample size at most one million. Equal unit cost, continuous unconstrained allocation only. Reject a target above a stratum population; equal-allocation variance is null when that comparison is infeasible. No rounding or fabricated sampled records. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [online.stat.psu.edu](https://online.stat.psu.edu/statprogram/stat506). No endorsement is implied.

Example input:

```json
{
  "sampleSize": 100,
  "strata": [
    {
      "population": 1000,
      "sd": 1
    },
    {
      "population": 1000,
      "sd": 3
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/continuousAllocation": [
    25,
    75
  ],
  "/estimatedMeanVariance": 0.0375,
  "/equalAllocationVariance": 0.0475
}
```

## Inclusion Weight Population Estimate

USD 19.00 per job.

Estimate a population total by Horvitz-Thompson weights and expose weight concentration. Valid supplied inclusion probabilities in(0,1], each distinct sampled unit once; no standard error without joint inclusion/design information. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [online.stat.psu.edu](https://online.stat.psu.edu/stat506/Lesson03). No endorsement is implied.

Example input:

```json
{
  "values": [
    10,
    20
  ],
  "inclusionProbabilities": [
    0.5,
    0.25
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/horvitzThompsonTotal": 100,
  "/hajekMean": 16.666666666666668,
  "/weightSum": 6,
  "/kishEffectiveSampleSize": 1.8
}
```

## Poststratified Population Estimate

USD 19.00 per job.

Adjust sample group means to independently supplied population group counts. Every population stratum needs observed data; within-stratum representativeness remains an assumption. No fabricated responses. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [search.r-project.org](https://search.r-project.org/CRAN/refmans/nrba/html/rake_to_benchmarks.html). No endorsement is implied.

Example input:

```json
{
  "strata": [
    {
      "population": 80,
      "sample": [
        5,
        15
      ]
    },
    {
      "population": 20,
      "sample": [
        25,
        35
      ]
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/populationMean": 14,
  "/populationTotal": 1400,
  "/unweightedSampleMean": 20
}
```

## Cluster Sample Design Effect

USD 19.00 per job.

Quantify the precision penalty of equal-size clusters under supplied intracluster correlation. Equal complete clusters, positive integer total divisible by cluster size and supplied intracluster correlation in[0,1]. DEFF=1+(m-1)rho. Descriptive planning approximation, no actual research/trial design or precision guarantee. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.ecdc.europa.eu](https://www.ecdc.europa.eu/sites/default/files/documents/Sample_size_guidance_for_surveillance_data.pdf). No endorsement is implied.

Example input:

```json
{
  "observations": 100,
  "clusterSize": 10,
  "intraclusterCorrelation": 0.1
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/designEffect": 1.9,
  "/effectiveIndependentSampleSize": 52.63157894736842
}
```

## Finite Population Mean Sample Plan

USD 19.00 per job.

Solve the finite-population normal-approximation sample size for a numeric mean margin. Population2 through one billion, supplied positive spread/margin and z<=10. Ceiling integer sample plans use variance=(1-n/N)*s^2/n. The unbounded plan must be at most10^12 for an unambiguous numeric integer; this is an arithmetic resource profile, not a payment limit. No confidence level is inferred from z. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [online.stat.psu.edu](https://online.stat.psu.edu/stat506/Lesson01). No endorsement is implied.

Example input:

```json
{
  "population": 100,
  "assumedSd": 10,
  "z": 2,
  "margin": 2
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/unboundedPopulationSampleSize": 100,
  "/finitePopulationSampleSize": 50,
  "/achievedApproximateMargin": 2
}
```

## Capture Recapture Coverage Estimate

USD 19.00 per job.

Estimate an unseen finite population from two overlapping independent enumerations with Chapman correction. Two list counts up to one million and nonnegative overlap no larger than either list. Closed population, correct matching, independence and equal catchability are assumptions. A zero-overlap Chapman extrapolation is extremely weak evidence, not verified unseen coverage; no identity resolution or population certification. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [online.stat.psu.edu](https://online.stat.psu.edu/stat506/Lesson12). No endorsement is implied.

Example input:

```json
{
  "firstCount": 9,
  "secondCount": 9,
  "overlapCount": 4
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/chapmanPopulationEstimate": 19,
  "/estimatedVariance": 16.666666666666668,
  "/observedUnion": 14,
  "/estimatedUnseen": 5
}
```

## Randomized Response Prevalence Scenario

USD 19.00 per job.

Invert a caller-defined forced-response survey mechanism to estimate aggregate prevalence. Up to one million respondents. Mechanism: truthful with probability t, forced yes with y, forced no with n, where t+y+n=1 and t>0. Estimate=(observedYesRate-y)/t. Out-of-range estimates remain visible with consistentWithMechanism=false; never silently clip. Respondent compliance remains assumed. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [online.stat.psu.edu](https://online.stat.psu.edu/stat506/Lesson12). No endorsement is implied.

Example input:

```json
{
  "respondents": 100,
  "yesResponses": 50,
  "truthfulProbability": 0.75,
  "forcedYesProbability": 0.125,
  "forcedNoProbability": 0.125
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/observedYesRate": 0.5,
  "/estimatedPrevalence": 0.5,
  "/estimatedTrueCount": 50
}
```

## Survey Nonresponse Identification Bounds

USD 19.00 per job.

Calculate exact worst-case binary population bounds when invited nonrespondents are wholly unknown. Arithmetic identification bounds, not a sampling confidence interval; all invited units assumed eligible. No imputation or missing-at-random claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [arxiv.org](https://arxiv.org/abs/2407.19339). No endorsement is implied.

Example input:

```json
{
  "invited": 100,
  "respondents": 60,
  "yesResponses": 36
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/respondentYesRate": 0.6,
  "/populationLowerBound": 0.36,
  "/populationUpperBound": 0.76,
  "/unknownCount": 40
}
```

## Auxiliary Ratio Population Total

USD 19.00 per job.

Use an observed outcome-to-auxiliary ratio with a known auxiliary population total. Positive auxiliary total; ratio estimator may be biased and requires a defensible proportional relationship. Does not claim known population truth. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [online.stat.psu.edu](https://online.stat.psu.edu/statprogram/stat506). No endorsement is implied.

Example input:

```json
{
  "auxiliary": [
    10,
    20
  ],
  "outcome": [
    20,
    50
  ],
  "auxiliaryPopulationTotal": 1000
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/sampleRatio": 2.3333333333333335,
  "/estimatedOutcomeTotal": 2333.3333333333335,
  "/sampleAuxiliaryTotal": 30,
  "/sampleOutcomeTotal": 70
}
```

## Iterative Margin Raking Report

USD 19.00 per job.

Fit a nonnegative supplied table to row and column margins by bounded iterative proportional fitting. Up to32-by-32 nonnegative cells, matched positive grand totals, fixed row/column targets, maximum2000 iterations. A bounded support-flow feasibility check rejects incompatible structural zeros before checkout. Alternate row/column fitting; convergence and margin error describe the delivered rounded table, so precision or iteration limits can leave converged=false. Fitted margins do not prove a true joint population distribution. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [r-survey.r-forge.r-project.org](https://r-survey.r-forge.r-project.org/survey/html/rake.html). No endorsement is implied.

Example input:

```json
{
  "table": [
    [
      1,
      1
    ],
    [
      1,
      1
    ]
  ],
  "rowTargets": [
    30,
    70
  ],
  "columnTargets": [
    40,
    60
  ],
  "tolerance": 0.000001,
  "maxIterations": 50
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/fittedTable": [
    [
      12,
      18
    ],
    [
      28,
      42
    ]
  ],
  "/maxMarginError": 0,
  "/converged": true
}
```

## Strict Increasing Subsequence API

USD 3.00 per job.

Return a longest increasing numeric subsequence with source indices. At most 512 safe integers. Strict comparisons; choose lexicographically smallest index sequence among maximum lengths. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [ocw.mit.edu](https://ocw.mit.edu/courses/6-006-introduction-to-algorithms-spring-2020/28461a74f81101874a13d9679a40584d_MIT6_006S20_lec16.pdf). No endorsement is implied.

Example input:

```json
{
  "values": [
    3,
    1,
    2,
    5,
    4
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/length": 3,
  "/indices": [
    1,
    2,
    3
  ],
  "/values": [
    1,
    2,
    5
  ]
}
```

## Palindromic Subsequence Length API

USD 3.00 per job.

Compute the maximum length of a palindromic token subsequence. At most 256 explicit tokens; interval DP. Report length only to avoid reversal-LCS reconstruction errors. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [xlinux.nist.gov](https://xlinux.nist.gov/dads/HTML/longestCommonSubsequence.html). No endorsement is implied.

Example input:

```json
{
  "tokens": [
    "b",
    "b",
    "b",
    "a",
    "b"
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/length": 4,
  "/minimumDeletions": 1
}
```

## Shortest Common Supersequence API

USD 3.00 per job.

Construct a shortest token sequence containing two inputs as subsequences. Each input at most 256 tokens. On equal DP lengths prefer left input's next token; exactly two inputs. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [xlinux.nist.gov](https://xlinux.nist.gov/dads/HTML/longestCommonSubsequence.html). No endorsement is implied.

Example input:

```json
{
  "left": [
    "a",
    "b"
  ],
  "right": [
    "a",
    "c"
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/length": 3,
  "/sequence": [
    "a",
    "b",
    "c"
  ]
}
```

## Maximum Contiguous Subarray API

USD 3.00 per job.

Locate a nonempty contiguous numeric interval with maximum sum. 1..4096 safe integers; checked sum. Ties prefer smallest start then shortest interval; no empty subarray. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [live.ocw.mit.edu](https://live.ocw.mit.edu/courses/6-006-introduction-to-algorithms-spring-2020/487dc976eabd0f9bcd6a3c385203ea27_MIT6_006S20_r16.pdf). No endorsement is implied.

Example input:

```json
{
  "values": [
    -2,
    3,
    -1,
    4,
    -5
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/sum": 6,
  "/start": 1,
  "/endExclusive": 4,
  "/values": [
    3,
    -1,
    4
  ]
}
```

## Sliding Window Extrema API

USD 3.00 per job.

Return minimum and maximum values for every complete fixed-width window. At most 4096 finite numbers; width 1..length. Monotonic deques or bounded scan; no padded windows. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [courses.cs.cornell.edu](https://courses.cs.cornell.edu/courses/cs2110/2026fa/lectures/lec15/). No endorsement is implied.

Example input:

```json
{
  "values": [
    4,
    2,
    2,
    5,
    1
  ],
  "width": 3
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/minimums": [
    2,
    2,
    1
  ],
  "/maximums": [
    4,
    5,
    5
  ]
}
```

## Next Greater Indices API

USD 3.00 per job.

Find the first strictly greater element to the right of each position. At most 4096 finite numbers. Equal values do not qualify; null explicitly denotes no next greater element. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [courses.cs.cornell.edu](https://courses.cs.cornell.edu/courses/cs2110/2026fa/lectures/lec15/). No endorsement is implied.

Example input:

```json
{
  "values": [
    2,
    1,
    2,
    4,
    3
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/indices": [
    3,
    2,
    3,
    null,
    null
  ],
  "/distances": [
    3,
    1,
    1,
    null,
    null
  ]
}
```

## Sequence Inversion Count API

USD 3.00 per job.

Count out-of-order index pairs using merge counting. At most 4096 safe integers. Count only i<j and value[i]>value[j]; duplicates are not inversions. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [algs4.cs.princeton.edu](https://algs4.cs.princeton.edu/code/javadoc/edu/princeton/cs/algs4/Inversions.html). No endorsement is implied.

Example input:

```json
{
  "values": [
    3,
    1,
    2,
    1
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/count": "4",
  "/sorted": [
    1,
    1,
    2,
    3
  ]
}
```

## Lehmer Permutation Codec API

USD 3.00 per job.

Convert a permutation of 0..n-1 to its zero-based lexicographic rank or invert it. Up to 100 members of 0 through n-1. Rank mode requires n equal to permutation length and rank="0"; unrank requires an empty permutation and 0<=rank<n!. Exact decimal-string ranks; empty permutation has rank zero. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [xlinux.nist.gov](https://xlinux.nist.gov/dads/HTML/permutation.html). No endorsement is implied.

Example input:

```json
{
  "mode": "rank",
  "permutation": [
    2,
    0,
    1
  ],
  "n": 3,
  "rank": "0"
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/rank": "4",
  "/digits": [
    2,
    0,
    0
  ],
  "/permutation": [
    2,
    0,
    1
  ]
}
```

## Least Cyclic Token Rotation API

USD 3.00 per job.

Find the lexicographically least cyclic rotation of explicit tokens. 1..2048 ASCII tokens; compare tokens by code-unit order. Equal rotations choose smallest source index; no locale collation. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [opus.lib.uts.edu.au](https://opus.lib.uts.edu.au/rest/bitstreams/82ece052-5d3c-45c1-80f9-c170809035e6/retrieve). No endorsement is implied.

Example input:

```json
{
  "tokens": [
    "b",
    "c",
    "a",
    "b"
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/start": 2,
  "/rotation": [
    "a",
    "b",
    "b",
    "c"
  ]
}
```

## Alternating Subsequence Length API

USD 3.00 per job.

Compute the longest subsequence whose nonzero adjacent differences alternate sign. At most 4096 finite numbers. Equal adjacent selected values cannot form an alternating step; empty input length 0. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.ocw.mit.edu](https://www.ocw.mit.edu/courses/6-006-introduction-to-algorithms-fall-2011/c316e062020649db5cda5785036c6fb8_MIT6_006F11_final.pdf). No endorsement is implied.

Example input:

```json
{
  "values": [
    1,
    7,
    4,
    9,
    2,
    5
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/length": 6,
  "/inputLength": 6
}
```

## Linear Cross Correlation API

USD 3.00 per job.

Compute full real cross correlation with explicit signed lag indices. Each vector 1..256 finite samples. r[k]=sum left[i]*right[i-k], out-of-range samples zero; no normalization or FFT. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.correlate.html). No endorsement is implied.

Example input:

```json
{
  "left": [
    1,
    2
  ],
  "right": [
    3,
    4
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/lags": [
    -1,
    0,
    1
  ],
  "/correlation": [
    4,
    11,
    6
  ]
}
```

## Causal IIR Filter Trace API

USD 3.00 per job.

Apply a bounded causal rational filter to supplied samples from zero initial history. Coefficient order <=16, samples<=2048, a[0] nonzero. Normalize by a[0]; reject nonfinite intermediate output; no stability or hardware claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.lfilter.html). No endorsement is implied.

Example input:

```json
{
  "b": [
    1
  ],
  "a": [
    1,
    -0.5
  ],
  "samples": [
    1,
    0,
    0,
    0
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/output": [
    1,
    0.5,
    0.25,
    0.125
  ],
  "/sampleCount": 4
}
```

## Orthonormal Haar Transform API

USD 3.00 per job.

Transform power-of-two real samples with multilevel Haar averages and details, or invert. Length power of two <=1024. Pair approximation=(x0+x1)/sqrt(2), detail=(x0-x1)/sqrt(2); layout coarse approximation then coarse-to-fine details; no padding. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [pywavelets.readthedocs.io](https://pywavelets.readthedocs.io/en/stable/ref/dwt-discrete-wavelet-transform.html). No endorsement is implied.

Example input:

```json
{
  "mode": "forward",
  "values": [
    1,
    1,
    1,
    1
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/coefficients": [
    2,
    0,
    0,
    0
  ],
  "/levels": 2,
  "/inputEnergy": 4,
  "/coefficientEnergy": 4
}
```

## DCT Type Two Transform API

USD 3.00 per job.

Compute an unnormalized real type-II discrete cosine transform. Unnormalized DCT-II, length 1 through 256. X[k]=2 sum x[j] cos(pi*k*(2j+1)/(2N)). Values at or below 8*machine-epsilon*N*sum(abs(input)) are set to zero; the threshold is returned. Numerical output, no exact-transform claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.fft.dct.html). No endorsement is implied.

Example input:

```json
{
  "values": [
    1,
    1
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/coefficients": [
    4,
    0
  ],
  "/length": 2
}
```

## Hann Window Coefficients API

USD 3.00 per job.

Generate a symmetric Hann taper and its aggregate gain and energy. Length 2..4096; symmetric denominator N-1. This is window construction, not spectral estimation; finite approximate coefficients. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.windows.hann.html). No endorsement is implied.

Example input:

```json
{
  "length": 5
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/coefficients": [
    0,
    0.5,
    1,
    0.5,
    0
  ],
  "/sum": 2,
  "/energy": 1.5
}
```

## Linear Sample Rate Conversion API

USD 3.00 per job.

Interpolate a uniformly sampled real sequence onto another declared sample rate. Linear interpolation of uniformly sampled values, including only output times at or before the final source sample. Endpoint membership uses the exact supplied finite binary rates, avoiding intermediate duration rounding. Equal rates preserve the source samples. No extrapolation or anti-alias filtering; not a band-limited resampler. At most 2048 input and 8192 output samples. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [numpy.org](https://numpy.org/doc/stable/reference/generated/numpy.interp.html). No endorsement is implied.

Example input:

```json
{
  "samples": [
    0,
    10,
    20
  ],
  "inputRate": 2,
  "outputRate": 4
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/samples": [
    0,
    5,
    10,
    15,
    20
  ],
  "/outputCount": 5,
  "/duration": 1
}
```

## Sample Peak Prominence API

USD 3.00 per job.

Measure topographic prominence and left/right bases for supplied strict local peaks. 3..2048 samples; reject endpoints/non-strict peaks to avoid plateau ambiguity. Scan until greater peak or boundary; equal base minima choose nearest peak. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [docs.scipy.org](https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.peak_prominences.html). No endorsement is implied.

Example input:

```json
{
  "samples": [
    0,
    3,
    1,
    2,
    0
  ],
  "peaks": [
    1,
    3
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/prominences": [
    3,
    1
  ],
  "/leftBases": [
    0,
    2
  ],
  "/rightBases": [
    4,
    4
  ]
}
```

## Linear Zero Crossing Locations API

USD 3.00 per job.

Locate adjacent strict sign changes by linear interpolation in sample coordinates. At most 4096 finite samples. Count only adjacent opposite nonzero signs; exact zero samples reported separately as zeroIndices and not counted as sign-change intervals. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [numpy.org](https://numpy.org/doc/stable/reference/generated/numpy.interp.html). No endorsement is implied.

Example input:

```json
{
  "samples": [
    -1,
    1,
    -1,
    1
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/positions": [
    0.5,
    1.5,
    2.5
  ],
  "/directions": [
    "rising",
    "falling",
    "rising"
  ],
  "/count": 3
}
```

## Decibel Ratio Conversion API

USD 3.00 per job.

Convert positive amplitude or power ratios to decibels and invert. At most 4096 finite values. Positive reference and positive inputs to log; power factor10, amplitude factor20. Inverse finite range only; no acoustic calibration claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.mathworks.com](https://www.mathworks.com/help/signal/ref/pow2db.html). No endorsement is implied.

Example input:

```json
{
  "mode": "to-db",
  "quantity": "power",
  "reference": 1,
  "values": [
    1,
    10,
    100
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/values": [
    0,
    10,
    20
  ],
  "/factor": 10
}
```

## Uniform Saturating Quantizer API

USD 3.00 per job.

Map real samples to a declared evenly spaced finite codebook and reconstruct them. 2..65536 levels, finite min<max, samples<=4096. Clamp to endpoints then nearest level; half-step ties toward higher code index; no dithering. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.mathworks.com](https://www.mathworks.com/help/comm/ug/quantization.html). No endorsement is implied.

Example input:

```json
{
  "minimum": -1,
  "maximum": 1,
  "levels": 5,
  "samples": [
    -0.8,
    -0.1,
    0.3,
    1.4
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/indices": [
    0,
    2,
    3,
    4
  ],
  "/quantized": [
    -1,
    0,
    0.5,
    1
  ],
  "/clippedCount": 1,
  "/step": 0.5
}
```

## Rooted Tree Traversal Profile API

USD 3.00 per job.

Derive traversal orders, node depths and subtree sizes from a parent vector. 1..512 nodes, exactly one -1 root, no cycles; children visited by ascending node id. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.princeton.edu](https://www.cs.princeton.edu/courses/archive/spring10/cos233/lectures/cos233-234-lecture6.pdf). No endorsement is implied.

Example input:

```json
{
  "parents": [
    -1,
    0,
    0,
    1
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/preorder": [
    0,
    1,
    3,
    2
  ],
  "/postorder": [
    3,
    1,
    2,
    0
  ],
  "/depths": [
    0,
    1,
    1,
    2
  ],
  "/subtreeSizes": [
    4,
    2,
    1,
    1
  ]
}
```

## Tree Lowest Common Ancestors API

USD 3.00 per job.

Answer ancestor queries on a supplied rooted tree. At most 512 nodes and 1024 queries. Validate one connected rooted tree; self is an ancestor. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [xlinux.nist.gov](https://xlinux.nist.gov/dads/HTML/lowestcommon.html). No endorsement is implied.

Example input:

```json
{
  "parents": [
    -1,
    0,
    0,
    1
  ],
  "queries": [
    [
      3,
      2
    ],
    [
      1,
      3
    ],
    [
      3,
      3
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/ancestors": [
    0,
    1,
    3
  ],
  "/distances": [
    3,
    1,
    0
  ]
}
```

## Tree All Root Distance Sums API

USD 3.00 per job.

Compute total unweighted distance from every vertex to every other vertex. 1..1024 vertices; n-1 unique undirected edges and connectivity. Rerooting or bounded BFS; sums are exact integers. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.princeton.edu](https://www.cs.princeton.edu/courses/archive/spring10/cos233/lectures/cos233-234-lecture6.pdf). No endorsement is implied.

Example input:

```json
{
  "nodes": 4,
  "edges": [
    [
      0,
      1
    ],
    [
      1,
      2
    ],
    [
      2,
      3
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/distanceSums": [
    6,
    4,
    4,
    6
  ],
  "/minimumSum": 4,
  "/minimizers": [
    1,
    2
  ]
}
```

## Tree Diameter and Centers API

USD 3.00 per job.

Measure longest unweighted tree distance and locate its centers. At most 1024 nodes. Center minimizes maximum distance; distinct from centroid, which balances component sizes. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.princeton.edu](https://www.cs.princeton.edu/courses/archive/spring10/cos233/lectures/cos233-234-lecture6.pdf). No endorsement is implied.

Example input:

```json
{
  "nodes": 4,
  "edges": [
    [
      0,
      1
    ],
    [
      1,
      2
    ],
    [
      2,
      3
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/diameter": 3,
  "/radius": 2,
  "/centers": [
    1,
    2
  ]
}
```

## Prufer Labeled Tree Codec API

USD 3.00 per job.

Encode or decode labeled trees using least-leaf Prufer elimination. Labeled trees with 2 through 512 vertices. Both modes require nodes, edges and code: encode requires code=[], decode requires edges=[] and exactly nodes-2 code labels. Least-leaf convention and sorted normalized edges; no file or device access. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [sites.math.rutgers.edu](https://sites.math.rutgers.edu/~wcf17/images/454_Lec12_7_18_2017.pdf). No endorsement is implied.

Example input:

```json
{
  "mode": "encode",
  "nodes": 4,
  "edges": [
    [
      0,
      1
    ],
    [
      0,
      2
    ],
    [
      0,
      3
    ]
  ],
  "code": []
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/code": [
    0,
    0
  ],
  "/degrees": [
    3,
    1,
    1,
    1
  ]
}
```

## Rooted Tree Canonical Shape API

USD 3.00 per job.

Canonicalize unordered rooted tree shape for exact isomorphism comparison. Unordered rooted tree shape, up to 512 nodes. A node is encoded as an opening parenthesis, sorted child encodings and closing parenthesis. Labels and child order are ignored; no unrooted isomorphism claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.imsc.res.in](https://www.imsc.res.in/~vikram/DiscreteMaths/2011/tree.pdf). No endorsement is implied.

Example input:

```json
{
  "parents": [
    -1,
    0,
    0
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/canonical": "(()())",
  "/nodeCount": 3,
  "/height": 1
}
```

## Binary Traversal Reconstruction API

USD 3.00 per job.

Reconstruct a unique binary tree from distinct-label preorder and inorder traversals. At most 256 unique labels; traversals must contain identical sets and be consistent. Height counts edges; empty tree height -1. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [www.cs.princeton.edu](https://www.cs.princeton.edu/courses/archive/spr99/cs126/comments/10tree.html). No endorsement is implied.

Example input:

```json
{
  "preorder": [
    "A",
    "B",
    "D",
    "C"
  ],
  "inorder": [
    "D",
    "B",
    "A",
    "C"
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/root": "A",
  "/postorder": [
    "D",
    "B",
    "C",
    "A"
  ],
  "/height": 2
}
```

## Binary Search Tree Operation Trace API

USD 3.00 per job.

Rehearse ordered insert, delete and search operations in an ordinary unbalanced BST. At most 512 safe-integer operations; duplicate insert is a no-op. Delete with two children replaces by inorder successor; no balancing claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [algs4.cs.princeton.edu](https://algs4.cs.princeton.edu/32bst/). No endorsement is implied.

Example input:

```json
{
  "operations": [
    {
      "op": "insert",
      "key": 2
    },
    {
      "op": "insert",
      "key": 1
    },
    {
      "op": "insert",
      "key": 3
    },
    {
      "op": "delete",
      "key": 2
    }
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/inorder": [
    1,
    3
  ],
  "/preorder": [
    3,
    1
  ],
  "/size": 2,
  "/height": 1
}
```

## Weighted Tree Independent Set API

USD 3.00 per job.

Find a maximum-weight nonadjacent vertex set in a tree. At most 512 nodes and nonnegative safe integer weights. DP with checked sum; ties compare sorted selected-id vectors lexicographically. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [ocw.mit.edu](https://ocw.mit.edu/courses/6-006-introduction-to-algorithms-spring-2008/2ca17b35ce6a91d78745e876a1bdf1f7_lec22.pdf). No endorsement is implied.

Example input:

```json
{
  "nodes": 4,
  "edges": [
    [
      0,
      1
    ],
    [
      0,
      2
    ],
    [
      0,
      3
    ]
  ],
  "weights": [
    4,
    2,
    2,
    2
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/maximumWeight": 6,
  "/selected": [
    1,
    2,
    3
  ]
}
```

## Tree Minimum Dominating Set API

USD 3.00 per job.

Find the fewest vertices covering every vertex through self or adjacency. At most 256 tree vertices. Use three-state tree DP; stable lexicographic selected-id tie rule. No general-graph optimum claim. Uses supplied non-sensitive data only. No live account access, automatic changes or certification. Calculation profile 1.0.0; approximate non-integer numeric outputs use twelve significant digits; representable safe integer numbers and declared decimal-string integers are preserved.

Reference: [ocw.mit.edu](https://ocw.mit.edu/courses/6-006-introduction-to-algorithms-spring-2008/2ca17b35ce6a91d78745e876a1bdf1f7_lec22.pdf). No endorsement is implied.

Example input:

```json
{
  "nodes": 4,
  "edges": [
    [
      0,
      1
    ],
    [
      0,
      2
    ],
    [
      0,
      3
    ]
  ]
}
```

Selected expected result fields (JSON pointers):

```json
{
  "/minimumSize": 1,
  "/selected": [
    0
  ]
}
```