| basis_oriented_quaternion |
Ran ran on a synthesized input |
yannbouteiller/gym-airsimdroneracinglab/gym_game_of_drones/envs/multi_agent/gym_airsimdroneracinglab/airsimdroneracinglab_env.py code served (permissive licence) · get_code("4f1fcee7a0959171") 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 Quaternion. 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
class Quaternion:
"""Stand-in quaternion class with inverse() method and multiplication support"""
def __init__(self, x, y, z, w):
self.x = x
self.y = y
self.z = z
self.w = w
def inverse(self):
"""Return the inverse of this quaternion"""
norm_sq = self.x**2 + self.y**2 + self.z**2 + self.w**2
return Quaternion(
-self.x / norm_sq,
-self.y / norm_sq,
-self.z / norm_sq,
self.w / norm_sq
)
def __mul__(self, other):
"""Quaternion multiplication"""
w1, x1, y1, z1 = self.w, self.x, self.y, self.z
w2, x2, y2, z2 = other.w, other.x, other.y, other.z
w = w1*w2 - x1*x2 - y1*y2 - z1*z2
x = w1*x2 + x1*w2 + y1*z2 - z1*y2
y = w1*y2 - x1*z2 + y1*w2 + z1*x2
z = w1*z2 + x1*y2 - y1*x2 + z1*w2
return Quaternion(x, y, z, w)
torch.manual_seed(0)
drone_base_orientation = Quaternion(x=0.1, y=0.2, z=0.3, w=0.9)
base_quaternion = Quaternion(x=0.05, y=0.15, z=0.25, w=0.95)
ARGS = {
"drone_base_orientation": drone_base_orientation,
"base_quaternion": base_quaternion
}
- 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 Quaternion — a Quaternion output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Quaternion 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
|
| collate |
Ran ran on a synthesized input |
rmst/rtrl/rtrl/util.py code served (permissive licence) · get_code("37983d1795ec599f") 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, 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 torch
import numpy as np
from collections.abc import Sequence, Mapping
torch.manual_seed(0)
# Test batch with torch tensors
batch_tensors = [
torch.randn(4, 3),
torch.randn(4, 3),
]
# Test batch with numpy arrays
batch_numpy = [
np.random.randn(4, 3),
np.random.randn(4, 3),
]
# Test batch with sequences (lists of tensors)
batch_sequences = [
(torch.randn(4, 3), torch.randn(5, 2)),
(torch.randn(4, 3), torch.randn(5, 2)),
]
# Test batch with mappings (dicts)
batch_mappings = [
{'x': torch.randn(4, 3), 'y': torch.randn(2,)},
{'x': torch.randn(4, 3), 'y': torch.randn(2,)},
]
# Test batch with custom objects that have __torch_tensor__
class TorchTensorWrapper:
def __init__(self, shape):
self._tensor = torch.randn(*shape)
def __torch_tensor__(self):
return self._tensor
batch_torch_tensor_protocol = [
TorchTensorWrapper((4, 3)),
TorchTensorWrapper((4, 3)),
]
# Test batch with scalars (fallback case)
batch_scalars = [1, 2, 3, 4]
ARGS = {
'batch': batch_tensors,
'device': None,
}
- 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, 3) — shape (2, 4, 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
|
| compute_assed_id |
Ran ran on a synthesized input |
elementai/avenue/avenue/util.py code served (permissive licence) · get_code("9e6f271628db1153") 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.
# Setup code for compute_assed_id
ARGS = {
'name': 'myapp',
'system': 'linux'
}
- 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
|
| compute_asset_path |
Ran ran on a synthesized input |
elementai/avenue/avenue/util.py code served (permissive licence) · get_code("3898cde4a2e9842f") 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
# Set up environment variable for assets directory (optional, tests default behavior)
os.environ['AVENUE_ASSETS'] = '/tmp/test_assets'
# The function takes a single parameter: asset_id
# It's used as a string to join with directory paths
asset_id = "model_v1.onnx"
ARGS = {
"asset_id": asset_id
}
- 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
|
| concat_spaces_from_dict |
Ran ran on a synthesized input |
elementai/avenue/avenue/wrappers.py code served (permissive licence) · get_code("38e629a2f8bc42de") 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 Box. 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 gym
import numpy as np
# Create gym.spaces.Box objects for the spaces dict
# The function expects spaces to have 'shape', 'low', 'high', and 'dtype' attributes
space1 = gym.spaces.Box(low=0.0, high=1.0, shape=(2, 3), dtype=np.float32)
space2 = gym.spaces.Box(low=0.0, high=1.0, shape=(2, 4), dtype=np.float32)
space3 = gym.spaces.Box(low=0.0, high=1.0, shape=(2, 5), dtype=np.float32)
spaces = {
'obs_1': space1,
'obs_2': space2,
'obs_3': space3,
}
keys = ['obs_1', 'obs_2', 'obs_3']
ARGS = {
'spaces': spaces,
'keys': keys,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- gym, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Box — a Box output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Box 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
|
| copy_shared |
Ran ran on a synthesized input |
rmst/rtrl/rtrl/nn.py code served (permissive licence) · get_code("f3ed23b35cd6dba4") 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 SimpleModel. 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 torch.nn as nn
from copy import deepcopy
torch.manual_seed(0)
# Create a simple model with some parameters
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.linear1 = nn.Linear(4, 3)
self.linear2 = nn.Linear(3, 2)
def forward(self, x):
x = self.linear1(x)
x = self.linear2(x)
return x
model_a = SimpleModel()
ARGS = {
"model_a": model_a
}
- 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 SimpleModel — a SimpleModel output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SimpleModel 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
|
| dqn_conv |
Ran ran on a synthesized input |
rmst/rtrl/rtrl/nn.py code served (permissive licence) · get_code("c64381a3a6c81fd5") 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 Sequential. 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 torch.nn as nn
torch.manual_seed(0)
ARGS = {
"n": 3
}
- 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 Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 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
|
| float64_to_float32 |
Ran ran on a synthesized input |
rmst/rtrl/rtrl/wrappers.py code served (permissive licence) · get_code("d4a1d5bcb45f2a7b") 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 (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
# Test case 1: float64 array that should be converted to float32
x_float64 = np.array([1.5, 2.7, 3.9], dtype=np.float64)
# Test case 2: float32 array that should remain unchanged
x_float32 = np.array([1.5, 2.7, 3.9], dtype=np.float32)
# We'll use the float64 case as the main argument since it exercises the conversion
ARGS = {
"x": x_float64
}
- 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 (3,) — shape (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
|
| get_wrapper_by_class |
Ran ran on a synthesized input |
rmst/rtrl/rtrl/wrappers.py code served (permissive licence) · get_code("49fd27673ae96565") 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 CustomWrapper. 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 gym
import torch
torch.manual_seed(0)
class DummyEnv(gym.Env):
def __init__(self):
self.observation_space = gym.spaces.Box(0, 1, shape=(4,))
self.action_space = gym.spaces.Discrete(2)
def reset(self):
return self.observation_space.sample()
def step(self, action):
return self.observation_space.sample(), 0, False, {}
def render(self):
pass
class CustomWrapper(gym.Wrapper):
def __init__(self, env):
super().__init__(env)
class AnotherWrapper(gym.Wrapper):
def __init__(self, env):
super().__init__(env)
# Create a nested wrapper structure
base_env = DummyEnv()
wrapped_env = CustomWrapper(base_env)
double_wrapped_env = AnotherWrapper(wrapped_env)
# Test case 1: env is already an instance of the target class
env_test_1 = wrapped_env
cls_test_1 = CustomWrapper
ARGS = {
"env": env_test_1,
"cls": cls_test_1
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- gym, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type CustomWrapper — a CustomWrapper output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a CustomWrapper 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
|
| min_max_norm |
Ran ran on a synthesized input |
elementai/avenue/avenue/util.py code served (permissive licence) · get_code("bbaf3f539ccf9404") 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 2, dtype family float, shape (2, 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 torch
import numpy as np
torch.manual_seed(0)
# Construct arguments for min_max_norm function
# The function performs min-max normalization: ((x - min_value) / (max_value - min_value) - 0.5) * 2
# It takes x (tensor/array), min_value (scalar), and max_value (scalar)
x = torch.randn(2, 4) # Small tensor: batch size 2, dimension 4
min_value = 0.0
max_value = 1.0
ARGS = {
"x": x,
"min_value": min_value,
"max_value": max_value
}
- 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 2, dtype family float, shape (2, 4) — shape (2, 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
|
| no_grad |
Ran ran on a synthesized input |
rmst/rtrl/rtrl/nn.py code served (permissive licence) · get_code("064f68f60a5e4279") 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 SimpleModel. 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 torch.nn as nn
torch.manual_seed(0)
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.linear1 = nn.Linear(4, 3)
self.linear2 = nn.Linear(3, 2)
def forward(self, x):
x = self.linear1(x)
x = self.linear2(x)
return x
model = SimpleModel()
ARGS = {
"model": model
}
- 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 SimpleModel — a SimpleModel output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SimpleModel 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
|
| partition |
Ran ran on a synthesized input |
rmst/rtrl/rtrl/util.py code served (permissive licence) · get_code("c0504dae0e2af9cc") 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 torch
from typing import Mapping
torch.manual_seed(0)
# The function partition() takes a single parameter 'x'
# It handles torch.Tensor and Mapping types
# For Mapping case: it creates a dict of partitioned values,
# then constructs tuples of new dicts with individual elements
# Test case 1: A simple Mapping (dict) with tensor values
test_dict = {
'a': torch.randn(2, 4),
'b': torch.randn(2, 3),
}
ARGS = {
'x': test_dict
}
- 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 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
|
| quaternion_to_euler |
Ran ran on a synthesized input |
yannbouteiller/gym-airsimdroneracinglab/gym_game_of_drones/dataset_collector_game.py code served (permissive licence) · get_code("445cd0db640c75dc") 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 (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
# The function takes a quaternion q as input
# q should be array-like with 4 elements: [x, y, z, w]
q = np.array([0.0, 0.0, 0.0, 1.0])
ARGS = {
"q": q
}
- 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 (3,) — shape (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
|
| quaternion_to_yaw |
Ran ran on a synthesized input |
yannbouteiller/gym-airsimdroneracinglab/gym_game_of_drones/envs/multi_agent/gym_airsimdroneracinglab/rewardfunction.py code served (permissive licence) · get_code("b4dafd10c6a29ce4") 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 numpy as np
class Quaternion:
def __init__(self, w, x, y, z):
self.w_val = w
self.x_val = x
self.y_val = y
self.z_val = z
q = Quaternion(
w=1.0,
x=0.0,
y=0.5,
z=0.3
)
ARGS = {
"q": q
}
- 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 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
|
| quaternions_to_gate_yaw_cos |
Ran ran on a synthesized input |
yannbouteiller/gym-airsimdroneracinglab/gym_game_of_drones/envs/multi_agent/gym_airsimdroneracinglab/rewardfunction.py code served (permissive licence) · get_code("fa1168e9585a6ae1") 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 numpy as np
class Quaternion:
def __init__(self, w, x, y, z):
self.w_val = w
self.x_val = x
self.y_val = y
self.z_val = z
def inverse(self):
# For a unit quaternion, inverse is the conjugate
norm_sq = self.w_val**2 + self.x_val**2 + self.y_val**2 + self.z_val**2
return Quaternion(
self.w_val / norm_sq,
-self.x_val / norm_sq,
-self.y_val / norm_sq,
-self.z_val / norm_sq
)
def __mul__(self, other):
# Quaternion multiplication
w = self.w_val * other.w_val - self.x_val * other.x_val - self.y_val * other.y_val - self.z_val * other.z_val
x = self.w_val * other.x_val + self.x_val * other.w_val + self.y_val * other.z_val - self.z_val * other.y_val
y = self.w_val * other.y_val - self.x_val * other.z_val + self.y_val * other.w_val + self.z_val * other.x_val
z = self.w_val * other.z_val + self.x_val * other.y_val - self.y_val * other.x_val + self.z_val * other.w_val
return Quaternion(w, x, y, z)
# Create two quaternion objects
q1 = Quaternion(w=0.9238795, x=0.0, y=0.3826834, z=0.0)
q2 = Quaternion(w=0.7071068, x=0.0, y=0.7071068, z=0.0)
ARGS = {
'q1': q1,
'q2': q2
}
- 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 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
|
| shallow_copy |
Ran ran on a synthesized input |
rmst/rtrl/rtrl/util.py code served (permissive licence) · get_code("592c3fc322538b71") 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 SimpleObject. 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)
class SimpleObject:
"""A simple test object with some attributes"""
def __init__(self):
self.value = 42
self.name = "test"
self.data = [1, 2, 3]
self.nested = {"key": "value"}
# Create an instance to shallow copy
obj = SimpleObject()
ARGS = {
"obj": obj
}
- 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 SimpleObject — a SimpleObject output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SimpleObject 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
|