| add_shoulders |
Ran ran on a synthesized input |
dribnet/plat/plat/sampling.py code served (permissive licence) · get_code("3fa640a95cb4a3ae") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# Create small dummy images (just numpy arrays or tensors)
# The function only uses len() and indexing on these, so simple arrays work
image1 = np.random.rand(3, 32, 32)
image2 = np.random.rand(3, 32, 32)
image3 = np.random.rand(3, 32, 32)
image4 = np.random.rand(3, 32, 32)
image5 = np.random.rand(3, 32, 32)
image6 = np.random.rand(3, 32, 32)
images = [image1, image2, image3, image4, image5, image6]
# Create anchor images (typically corner/edge images)
anchor1 = np.random.rand(3, 32, 32)
anchor2 = np.random.rand(3, 32, 32)
anchor3 = np.random.rand(3, 32, 32)
anchor_images = [anchor1, anchor2, anchor3]
# Grid dimensions
rows = 3
cols = 2
ARGS = {
"images": images,
"anchor_images": anchor_images,
"rows": rows,
"cols": cols,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| additive_composite |
Ran ran on a synthesized input |
dribnet/plat/plat/bin/canvas.py code served (permissive licence) · get_code("4695bd5cc5fe570c") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 3, dtype family float, shape (4, 3, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Examine the function to understand what it needs:
# - src: accessed with [rgb] and [alpha] indexing, needs shape (4, height, width) with channels
# - src_mask: either None or accessed with [alpha] indexing, can be None or array
# - dst: accessed with [alpha] and [rgb] indexing, needs shape (4, height, width)
# Create small numpy arrays with distinct dimensions
height = 3
width = 5
# src: 4 channels (RGBA), height=3, width=5
src = np.random.rand(4, height, width).astype('float32')
# src_mask: either None or a mask array for alpha channel
src_mask = np.random.rand(height, width).astype('float32')
# dst: 4 channels (RGBA), height=3, width=5
dst = np.random.rand(4, height, width).astype('float32')
ARGS = {
'src': src,
'src_mask': src_mask,
'dst': dst,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 3, dtype family float, shape (4, 3, 5) — shape (4, 3, 5) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| alpha_composite |
Ran ran on a synthesized input |
dribnet/plat/plat/bin/canvas.py code served (permissive licence) · get_code("c001793a18ea82fe") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 3, dtype family float, shape (4, 2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create small RGBA images with shape (4, height, width)
# src: source image with alpha channel
src = np.random.rand(4, 2, 3).astype('float32')
# src_mask: alpha mask for source (can be None or a mask array)
src_mask = np.random.rand(2, 3).astype('float32')
# dst: destination image with alpha channel
dst = np.random.rand(4, 2, 3).astype('float32')
ARGS = {
'src': src,
'src_mask': src_mask,
'dst': dst
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 3, dtype family float, shape (4, 2, 3) — shape (4, 2, 3) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| filter_attributes |
Ran ran on a synthesized input |
dribnet/plat/plat/bin/atvec.py code served (permissive licence) · get_code("e87e50f4ec870631") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 3, dtype family float, shape (2, 4, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# Create a small 3D tensor: (batch=2, sequence=4, attributes=5)
attribs = torch.randn(2, 4, 5)
# Test case 1: which_attribs is None (returns original)
ARGS = {
'attribs': attribs,
'which_attribs': None
}
# Alternative test case 2: which_attribs filters to specific indices
# ARGS = {
# 'attribs': attribs,
# 'which_attribs': '0,2,4'
# }
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 3, dtype family float, shape (2, 4, 5) — shape (2, 4, 5) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_averages |
Ran ran on a synthesized input |
dribnet/plat/plat/bin/atvec.py code served (permissive licence) · get_code("69c23b3721421350") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import torch
# Set seed for reproducibility
torch.manual_seed(0)
np.random.seed(0)
# Create sample data
num_items = 2
num_attribs = 3
encoded_dim = 4
# attribs should be shape (num_items, 1, num_attribs)
# with values of 0 or 1 indicating presence/absence of attributes
attribs = np.random.randint(0, 2, size=(num_items, 1, num_attribs)).astype(np.float32)
# encoded should be shape (num_items, encoded_dim)
# contains the encoded representations for each item
encoded = np.random.randn(num_items, encoded_dim).astype(np.float32)
ARGS = {
'attribs': attribs,
'encoded': encoded
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_class_averages |
Ran ran on a synthesized input |
dribnet/plat/plat/bin/atvec.py code served (permissive licence) · get_code("88d5514f4345aafe") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create small stand-in data
num_classes = 3
num_samples = 25
# attribs: list of arrays where attribs[i][0] is the class index
attribs = [np.array([i % num_classes]) for i in range(num_samples)]
# encoded: list of feature vectors (or arrays)
# Using shape (num_samples, 4) where 4 is the feature dimension
encoded = [np.random.randn(4) for i in range(num_samples)]
ARGS = {
"attribs": attribs,
"encoded": encoded,
"num_classes": num_classes,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_json_vectors |
Ran ran on a synthesized input |
dribnet/plat/plat/utils.py code served (permissive licence) · get_code("c04dd2fcc1e23ad9") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (3, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
import json
import tempfile
import os
# Create a temporary JSON file with vector data
temp_dir = tempfile.mkdtemp()
filename = os.path.join(temp_dir, "vectors.json")
# Write sample vector data to JSON file
vectors_data = [
[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0],
[9.0, 10.0, 11.0, 12.0]
]
with open(filename, 'w') as f:
json.dump(vectors_data, f)
ARGS = {
"filename": filename
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 2, dtype family float, shape (3, 4) — shape (3, 4) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| grid2img |
Ran ran on a synthesized input |
dribnet/plat/plat/grid_layout.py code served (permissive licence) · get_code("874d0c68ae78d3bb") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Image. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
from PIL import Image
# Create a small grid of images
# Each image has shape (channels, height, width)
arr = [
np.random.rand(3, 4, 5).astype(np.float32), # 3 channels, 4 height, 5 width
np.random.rand(3, 4, 5).astype(np.float32),
np.random.rand(3, 4, 5).astype(np.float32),
np.random.rand(3, 4, 5).astype(np.float32),
]
ARGS = {
"arr": arr,
"rows": 2,
"cols": 2,
"with_space": False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- PIL, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 and dtype family int describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| lerp |
Ran ran on a synthesized input |
dribnet/plat/plat/interpolate.py code served (permissive licence) · get_code("ee023c21ffe38ef3") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
ARGS = {
"val": 0.5,
"low": 1.0,
"high": 10.0,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| lerp_gaussian |
Ran ran on a synthesized input |
dribnet/plat/plat/interpolate.py code served (permissive licence) · get_code("2491fa1841f23907") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float64, ndim 0, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
from scipy.stats import norm
torch.manual_seed(0)
# Analyze the function signature:
# lerp_gaussian(val, low, high)
# The function takes three numeric parameters and performs:
# - norm.cdf(low)
# - norm.cdf(high)
# - lerp(val, low_gau, high_gau) which does: low_gau + (high_gau - low_gau) * val
# - norm.ppf(lerped_gau)
# All parameters are used in arithmetic operations with scalar/array values
# They should be numeric types (float, int, or numpy/torch arrays)
ARGS = {
"val": 0.5, # scalar between 0 and 1 for interpolation
"low": -2.0, # scalar for lower bound
"high": 2.0, # scalar for upper bound
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| load_model_with_interface |
Ran ran on a synthesized input |
dribnet/plat/plat/zoo.py code served (permissive licence) · get_code("b6f6cf45195382a5") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned MockModelClass. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import sys
import importlib
import tempfile
from unittest.mock import Mock, patch, MagicMock
# Create a mock model class that will be importable
class MockModelClass:
def __init__(self, filename):
self.filename = filename
self.loaded = True
# Create a temporary module to simulate the model interface
mock_module = MagicMock()
mock_module.MockModel = MockModelClass
# Patch importlib.import_module to return our mock module
original_import_module = importlib.import_module
def patched_import_module(name):
if name == 'my_models.interface':
return mock_module
return original_import_module(name)
# Create a temporary model file path (won't actually be created, just a path string)
model_file_path = '/tmp/mock_model.pt'
# Define the arguments
ARGS = {
'model_file_name': model_file_path,
'model_interface': 'my_models.interface.MockModel'
}
# Monkey-patch importlib to use our mock
importlib.import_module = patched_import_module
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type MockModelClass — a MockModelClass output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a MockModelClass output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| remove_duplicates |
Ran ran; our contract draft was wrong, not the code |
gitaar9/MLDAGAN/dagan_architectures.py code served (permissive licence) · get_code("e73857dab63b5298") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
class FeatureLayer:
def __init__(self, name, tensor):
self.name = name
self.tensor = tensor
# Create a list of feature layers with some duplicates
input_features = [
FeatureLayer("layer1", torch.randn(2, 4)),
FeatureLayer("layer2", torch.randn(2, 3)),
FeatureLayer("layer1", torch.randn(2, 4)), # duplicate name
FeatureLayer("layer3", torch.randn(2, 5)),
FeatureLayer("layer2", torch.randn(2, 3)), # duplicate name
FeatureLayer("layer4", torch.randn(2, 6)),
]
ARGS = {
"input_features": input_features
}
- Setup block drafted by
- a language model, Claude Sonnet 4.5, prompt python_fixture_v1
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| resolve_model_to_filename |
Ran ran on a synthesized input |
dribnet/plat/plat/zoo.py code served (permissive licence) · get_code("aee9dcd8433bb6d9") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import tempfile
import shutil
# Create a temporary directory to act as the platzoo directory
temp_dir = tempfile.mkdtemp()
plat_dir = os.path.join(temp_dir, 'plat')
os.makedirs(plat_dir, exist_ok=True)
zoo_dir = os.path.join(plat_dir, 'zoo')
os.makedirs(zoo_dir, exist_ok=True)
# Set environment variable for the test
os.environ['PLAT_DIR'] = plat_dir
# Define arguments for resolve_model_to_filename
ARGS = {
'filename': 'model.pkl'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| resolve_model_type_from_filename |
Ran ran on a synthesized input |
dribnet/plat/plat/zoo.py code served (permissive licence) · get_code("4ee8364367586c42") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# The function takes a filename string and splits it by '.' to get the extension
# It checks if the last part is 'pth' and returns a model type string
# No complex objects needed - just a string parameter
ARGS = {
'filename': 'model.pth'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| slerp |
Ran ran on a synthesized input |
dribnet/plat/plat/interpolate.py code served (permissive licence) · get_code("9c1b90f679a7f761") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family float, shape (4,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Construct small vector arguments for slerp
# The function expects val (scalar), low (vector), and high (vector)
val = 0.5
# Create two random unit vectors for low and high
# These should be normalized so arccos can work properly
np.random.seed(0)
low = np.random.randn(4)
low = low / np.linalg.norm(low)
high = np.random.randn(4)
high = high / np.linalg.norm(high)
ARGS = {
"val": val,
"low": low,
"high": high
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 1, dtype family float, shape (4,) — shape (4,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|