| align_z |
Ran ran on a synthesized input |
StanfordASL/CoCo/manipulation/utils.py code served (permissive licence) · get_code("137827b39c64e2cd") 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, 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
ARGS = {
'v': np.array([0.5, 0.3, 0.8])
}
- 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, 3) — shape (3, 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
|
| count_occurrences |
Ran ran on a synthesized input |
bstellato/mlopt/mlopt/sampling.py code served (permissive licence) · get_code("a2018ad56865ac15") 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 int, ndim 0, dtype family int, 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 numpy as np
# The function count_occurrences takes:
# - labels: a numpy array of labels
# - i: an integer value to count occurrences of
# Create a simple numpy array of labels
labels = np.array([0, 1, 2, 1, 0, 2, 1, 0])
# Create an integer value to count
i = 1
ARGS = {
"labels": labels,
"i": i
}
- 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 int, ndim 0, dtype family int, 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
|
| create_kkt_system |
Ran ran on a synthesized input |
bstellato/mlopt/mlopt/kkt.py code served (permissive licence) · get_code("dc982b26a4eb7860") 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 cvxpy.settings as cps
import scipy.sparse as spa
import numpy as np
# Create a minimal data dictionary with required keys
n_variables = 4
n_constraints = 3
# Create a small positive definite matrix for P
P = spa.csc_matrix(np.array([
[2.0, 0.5, 0.0, 0.0],
[0.5, 2.0, 0.0, 0.0],
[0.0, 0.0, 1.5, 0.0],
[0.0, 0.0, 0.0, 1.5]
]))
# Create a constraint matrix A (n_constraints x n_variables)
A_reduced = spa.csc_matrix(np.array([
[1.0, 1.0, 0.5, 0.2],
[0.0, 1.0, 1.0, 0.3],
[0.5, 0.0, 1.0, 1.0]
]))
# Create Q vector (n_variables,)
Q = np.array([1.0, 2.0, 0.5, 1.5])
# Create B vector (n_constraints,)
B_reduced = np.array([5.0, 3.0, 4.0])
# Construct data dictionary with cvxpy.settings keys
data = {
cps.P: P,
cps.A + '_red': A_reduced,
cps.Q: Q,
cps.B + '_red': B_reduced
}
ARGS = {
'data': data
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- cvxpy, numpy, scipy — 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
|
| cylinder_grasp_from_normal |
Ran ran on a synthesized input |
StanfordASL/CoCo/manipulation/utils.py code served (permissive licence) · get_code("9add8ce8a8cd2908") 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
# The function signature is:
# cylinder_grasp_from_normal(v, h, r)
# where:
# v is a vector (3D array)
# h is a scalar (height)
# r is a scalar (radius)
# Create valid arguments
v = np.array([0.1, 0.2, 0.5]) # A 3D normal vector pointing mostly upward
h = 1.0 # height parameter
r = 0.3 # radius parameter
ARGS = {
"v": v,
"h": h,
"r": r,
}
- 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 — 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
|
| find_obs |
Ran ran on a synthesized input |
StanfordASL/CoCo/free_flyer/utils.py code served (permissive licence) · get_code("d1fe838ee72a7530") 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 list, ndim 2, 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
# Set random seed for reproducibility
np.random.seed(0)
# Define parameters for find_obs function
x0 = np.array([1.0, 1.0]) # Starting position
n_obs = 2 # Number of obstacles to generate
posmin = np.array([0.0, 0.0]) # Minimum position bounds
posmax = np.array([10.0, 10.0]) # Maximum position bounds
border_size = 0.5 # Border size around obstacles
box_buffer = 0.2 # Buffer around obstacle boxes
min_box_size = 0.5 # Minimum obstacle box size
max_box_size = 2.0 # Maximum obstacle box size
max_iter = 100 # Maximum iterations for obstacle generation
ignore_intersection = True # Whether to ignore obstacle intersections
ARGS = {
'x0': x0,
'n_obs': n_obs,
'posmin': posmin,
'posmax': posmax,
'border_size': border_size,
'box_buffer': box_buffer,
'min_box_size': min_box_size,
'max_box_size': max_box_size,
'max_iter': max_iter,
'ignore_intersection': ignore_intersection
}
- 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 list, ndim 2, 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
|
| generate_first_N_primes |
Ran ran on a synthesized input |
StanfordASL/CoCo/manipulation/halton_sampling.py code served (permissive licence) · get_code("5ed80f4b510304ee") 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 list, ndim 1, dtype family int; 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
def generate_first_N_primes(N):
ii, jj, flag = (0, 0, 0)
primes = []
for ii in range(1, N + 1, 1):
if ii == 1 or ii == 0:
continue
flag = 1
for jj in range(2, ii // 2 + 1, 1):
if ii % jj == 0:
flag = 0
break
if flag == 1:
primes.append(ii)
return primes
ARGS = {
"N": 20
}
- 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 list, ndim 1, dtype family int — 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
|
| generate_halton_samples |
Ran ran on a synthesized input |
StanfordASL/CoCo/manipulation/halton_sampling.py code served (permissive licence) · get_code("c2c10a8d08b38d3a") 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 (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 numpy as np
# Analyze the function signature and body:
# generate_halton_samples(dim, n, sf=[1])
# - dim: integer, dimensionality
# - n: integer, number of samples
# - sf: list/array of scaling factors, default [1]
# The function uses:
# - generate_first_N_primes(1000) to get prime numbers
# - len(sf) compared to dim
# - sf[idx] to index into scaling factors
# - generate_halton_sequence(n, base_val) for each dimension
# Small test values
dim = 4
n = 3
sf = np.array([1.0, 1.0, 1.0, 1.0])
ARGS = {
'dim': dim,
'n': n,
'sf': sf
}
- 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 (4, 3) — shape (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
|
| generate_halton_sequence |
Ran ran on a synthesized input |
StanfordASL/CoCo/manipulation/halton_sampling.py code served (permissive licence) · get_code("5bd46aa88457ea8d") 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 (10,) 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
ARGS = {
"n": 10,
"base": 2
}
- 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 (10,) — shape (10,) 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_n_processes |
Ran ran on a synthesized input |
bstellato/mlopt/mlopt/utils.py code served (permissive licence) · get_code("fc2f60aba08f5e4c") 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 int, ndim 0, dtype family int, 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 numpy as np
import os
import joblib
# The function get_n_processes takes one parameter: max_n
# It uses max_n to compute: min(max_n, n_cpus)
# max_n defaults to np.inf and should be a numeric value
# We'll test with a reasonable integer value
ARGS = {
'max_n': 4
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- joblib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type int, ndim 0, dtype family int, 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
|
| is_free_state |
Ran ran on a synthesized input |
StanfordASL/CoCo/free_flyer/utils.py code served (permissive licence) · get_code("9bfc400e168c3407") 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 bool, 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
import numpy as np
torch.manual_seed(0)
# x0 is a state (position) represented as a list or array-like with at least 2 elements [x, y]
x0 = [2.5, 3.5]
# obstacles is a list of obstacle definitions, where each obstacle is [x_min, x_max, y_min, y_max]
obstacles = [
[0.0, 1.0, 0.0, 1.0], # obstacle 1: x in [0, 1], y in [0, 1]
[3.0, 4.0, 3.0, 4.0], # obstacle 2: x in [3, 4], y in [3, 4]
]
# posmin and posmax define the bounds of the valid position space
posmin = [0.0, 0.0]
posmax = [10.0, 10.0]
ARGS = {
"x0": x0,
"obstacles": obstacles,
"posmin": posmin,
"posmax": posmax,
}
- 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 bool, 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
|
| is_pickleable |
Ran ran on a synthesized input |
bstellato/mlopt/mlopt/problem.py code served (permissive licence) · get_code("7bc48fcb12a1967f") 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 bool, 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 pickle
import torch
import torch.nn as nn
torch.manual_seed(0)
# Test with various pickleable and non-pickleable objects
pickleable_obj = {"key": "value", "number": 42, "list": [1, 2, 3]}
tensor_obj = torch.randn(2, 4)
list_obj = [1, 2, 3, "test"]
simple_class_obj = 42
# Create a simple nn.Module that is pickleable
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 3)
def forward(self, x):
return self.linear(x)
model_obj = SimpleModel()
# Test with various objects
ARGS = {
"obj": pickleable_obj
}
- 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 bool, 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
|
| n_features |
Ran ran on a synthesized input |
bstellato/mlopt/mlopt/utils.py code served (permissive licence) · get_code("f0786d99f7c22878") 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 int, ndim 0, dtype family int, 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 pandas as pd
import numpy as np
# Create a dataframe where cells contain tuples
# The function sums the sizes of flattened tuples in the first row
df = pd.DataFrame({
'col1': [(1, 2, 3), (4, 5, 6)],
'col2': [(7, 8), (9, 10)],
'col3': [np.array([11, 12, 13, 14]), np.array([15, 16, 17, 18])]
})
ARGS = {
'df': df
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type int, ndim 0, dtype family int, 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
|
| obs_intersect |
Ran ran on a synthesized input |
StanfordASL/CoCo/free_flyer/utils.py code served (permissive licence) · get_code("37170b6175afdf5d") 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 bool, 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
import numpy as np
torch.manual_seed(0)
# The function obs_intersect takes two observations and checks if they intersect
# based on bounding box logic. Each obs appears to be a sequence/array with at least 4 elements
# accessed via indices 0, 1, 2, 3 (likely [x_min, x_max, y_min, y_max] or similar 2D bbox format)
# Create two observations as lists/tuples representing 2D bounding boxes
# Format appears to be: [dim0_min, dim0_max, dim1_min, dim1_max]
obs_1 = [1.0, 5.0, 2.0, 6.0] # x: 1-5, y: 2-6
obs_2 = [3.0, 7.0, 4.0, 8.0] # x: 3-7, y: 4-8 (intersects with obs_1)
ARGS = {
"obs_1": obs_1,
"obs_2": obs_2,
}
- 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 bool, 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
|
| pandas2array |
Ran ran on a synthesized input |
bstellato/mlopt/mlopt/utils.py code served (permissive licence) · get_code("fc846b70a5af775a") 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 int, shape (2, 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
import pandas as pd
# Test case 1: numpy array (should be returned as-is)
X_numpy = np.array([[1, 2, 3], [4, 5, 6]])
# Test case 2: DataFrame with simple scalar values
X_df_simple = pd.DataFrame({
'col1': [1, 2, 3],
'col2': [4, 5, 6],
'col3': [7, 8, 9]
})
# Test case 3: DataFrame with tuple elements (the main use case)
X_df_tuples = pd.DataFrame({
'col1': [(1, 2), (3, 4)],
'col2': [(5, 6), (7, 8)],
'col3': [9, 10]
})
# Test case 4: Series (should be converted to DataFrame and transposed)
X_series = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
# Use the numpy array version for the main test
ARGS = {
'X': X_df_tuples
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — 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 int, shape (2, 5) — shape (2, 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
|
| populate_and_solve |
Ran ran on a synthesized input |
bstellato/mlopt/mlopt/problem.py code served (permissive licence) · get_code("f967f5292af2a4df") 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 dict. 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 StandInProblem:
"""Minimal problem class with populate and solve methods."""
def __init__(self):
self.theta_value = None
def populate(self, theta):
"""Store theta in the problem."""
self.theta_value = theta
def solve(self):
"""Solve and return results."""
if self.theta_value is None:
raise ValueError("Problem not populated")
# Return a simple result dict
return {
"solution": self.theta_value * 2,
"status": "solved"
}
# Create problem instance
problem = StandInProblem()
# Create theta as a simple tensor or array
theta = torch.tensor([1.0, 2.0, 3.0, 4.0])
ARGS = {
"problem": problem,
"theta": theta
}
- 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 dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict 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
|
| skew |
Ran ran on a synthesized input |
StanfordASL/CoCo/manipulation/utils.py code served (permissive licence) · get_code("e82c6a4c608cad2b") 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, 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
def skew(v):
out = np.array([[0.0, -v[2], v[1]], [v[2], 0.0, -v[0]], [-v[1], v[0], 0.0]])
return out
# The function takes a vector v and constructs a skew-symmetric matrix
# v must be indexable with indices 0, 1, 2 (a 3-element vector)
v = np.array([1.0, 2.0, 3.0])
ARGS = {
'v': v
}
- 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, 3) — shape (3, 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
|
| uniform_sphere_sample |
Ran ran on a synthesized input |
bstellato/mlopt/mlopt/sampling.py code served (permissive licence) · get_code("e8010cc38c163110") 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, 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
from scipy.special import gammainc
np.random.seed(42)
ARGS = {
"center": np.array([0.0, 0.0, 0.0]),
"radius": 1.5,
"n": 3
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — 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, 3) — shape (3, 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
|
| unique_strategies |
Ran ran on a synthesized input |
bstellato/mlopt/mlopt/strategy.py code served (permissive licence) · get_code("68ad7954b7f37a93") 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 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
class Strategy:
"""Simple Strategy class for testing."""
def __init__(self, name):
self.name = name
def __hash__(self):
return hash(self.name)
def __eq__(self, other):
if not isinstance(other, Strategy):
return False
return self.name == other.name
def __repr__(self):
return f"Strategy({self.name})"
torch.manual_seed(0)
strategy1 = Strategy("strategy_a")
strategy2 = Strategy("strategy_b")
strategy3 = Strategy("strategy_a")
strategy4 = Strategy("strategy_c")
strategies = [strategy1, strategy2, strategy3, strategy4]
ARGS = {
"strategies": strategies
}
- 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 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
|
| create_kkt_matrix |
Not yet run unverified (harvested, no recorded run) |
bstellato/mlopt/mlopt/kkt.py code served (permissive licence) · get_code("7f161af54975aa0a") How it ran |
| create_kkt_rhs |
Not yet run unverified (harvested, no recorded run) |
bstellato/mlopt/mlopt/kkt.py code served (permissive licence) · get_code("ebc080c85115e411") How it ran |
| sample_around_points |
Not yet run unverified (harvested, no recorded run) |
bstellato/mlopt/mlopt/sampling.py code served (permissive licence) · get_code("e73f5be563a1d3cd") How it ran |