| augment_state |
Ran ran on a synthesized input |
erdc/pynirom/pynirom/node/node.py code served (permissive licence) · get_code("8fcd97a3976f6f38") 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 tensorflow as tf
# Create small test arrays
state_array = np.random.randn(2, 4).astype(np.float32)
time_array = np.array([0.0, 1.0]).astype(np.float32)
aug_dim = 3
ARGS = {
"state_array": state_array,
"time_array": time_array,
"aug_dim": aug_dim,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, tensorflow — 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
|
| compute_interp_matrix |
Ran ran on a synthesized input |
erdc/pynirom/pynirom/rbf/rbf.py code served (permissive licence) · get_code("f01dee026cdb9d91") 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 scipy.spatial.distance
# Create small test data for the function
# The function expects Zsnap to be a dictionary of mode arrays
# Each array should have shape (num_modes, num_snapshots)
# Create distinct sizes for different components
# Component 1: 3 modes, 5 snapshots
component_1 = np.random.randn(3, 5)
# Component 2: 2 modes, 5 snapshots
component_2 = np.random.randn(2, 5)
# Build Zsnap dictionary
Zsnap = {
'h': component_1,
'u': component_2
}
# Nt should be num_snapshots - 1 (as per function docstring)
Nt = 4
# Epsilon parameter for RBF kernel
epsilon = 0.05
# Beta parameter for some RBF kernels
beta = 2.5
# RBF kernel type to use
rbf_kernel = 'matern'
ARGS = {
'Zsnap': Zsnap,
'Nt': Nt,
'rbf_kernel': rbf_kernel,
'epsilon': epsilon,
'beta': beta
}
- 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 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
|
| compute_kernel |
Ran ran on a synthesized input |
erdc/pynirom/pynirom/rbf/rbf.py code served (permissive licence) · get_code("7bca82596cbfac78") 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
# Create a small distance matrix as rij parameter
# This should be a 2D array of pairwise distances between RBF centers
rij = np.array([[0.0, 1.5, 2.3],
[1.5, 0.0, 1.8],
[2.3, 1.8, 0.0]])
ARGS = {
'rij': rij,
'rbf_kernel': 'matern',
'epsilon': 0.05
}
- 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
|
| compute_pod_multicomponent |
Ran ran; our contract draft was wrong, not the code |
erdc/node_nirom/notebooks/node_cylinder.py code served (permissive licence) · get_code("e67299e850b73c74") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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
import scipy
# Create sample snapshot data for multiple components
# S_pod is a dictionary where each key maps to an M x N array of snapshots
# Using distinct dimensions: 5 spatial points, 8 time snapshots for first component
# and 6 spatial points, 8 time snapshots for second component
component1_snapshots = np.random.randn(5, 8)
component2_snapshots = np.random.randn(6, 8)
S_pod = {
'velocity': component1_snapshots,
'pressure': component2_snapshots
}
ARGS = {
'S_pod': S_pod,
'subtract_mean': True,
'subtract_initial': False,
'full_matrices': False
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- numpy, scipy — 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
|
| compute_rbf |
Ran ran on a synthesized input |
erdc/pynirom/pynirom/rbf/rbf.py code served (permissive licence) · get_code("cdaa0af2555ce42a") 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 scipy.spatial.distance
# Create minimal test data for compute_rbf
# The function expects Zsnap_rbf to be a dictionary of snapshot arrays
# Each value should be a 2D array: (num_modes, num_snapshots)
np.random.seed(0)
# Create small snapshot arrays for different state variables
# Using distinct sizes: 4 modes, 6 snapshots
Zsnap_rbf = {
'h': np.random.randn(4, 6), # 4 modes, 6 snapshots
'u': np.random.randn(3, 6), # 3 modes, 6 snapshots
}
# Create time array matching number of snapshots
time_rbf = np.linspace(0, 1, 6)
# Define the ARGS dictionary with all parameters for compute_rbf
ARGS = {
'Zsnap_rbf': Zsnap_rbf,
'time_rbf': time_rbf,
'ep': 0.05,
'beta': 2.5,
'rbf_kernel': 'matern'
}
- 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 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
|
| compute_trunc_basis |
Ran ran; our contract draft was wrong, not the code |
erdc/node_nirom/notebooks/node_cylinder.py code served (permissive licence) · get_code("742ed8bc9159b522") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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
import numpy as np
torch.manual_seed(0)
# Create small singular value arrays for each component
# D should be a dictionary where each value is a 1D array of singular values
D = {
'component_1': np.array([10.0, 5.0, 2.0, 0.5, 0.1]),
'component_2': np.array([8.0, 4.0, 1.5, 0.3]),
}
# Create left singular basis vector arrays
# U should be a dictionary where each value is a 2D array
# Shape should be (n_features, n_singular_values)
U = {
'component_1': np.random.randn(6, 5), # 6 features, 5 singular values
'component_2': np.random.randn(4, 4), # 4 features, 4 singular values
}
# eng_cap is a float representing the energy capture threshold
eng_cap = 0.999999
ARGS = {
'D': D,
'U': U,
'eng_cap': eng_cap,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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, 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
|
| compute_trunc_basis |
Ran ran on a synthesized input |
erdc/pynirom/pynirom/pod/pod_utils.py code served (permissive licence) · get_code("ea93e60cd93f4d0c") 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
# Construct small, valid test data for compute_trunc_basis
# The function expects:
# D: dictionary of singular values (1D arrays)
# U: dictionary of left singular basis vectors (2D arrays)
# eng_cap: float between 0 and 1
# user_rank: dictionary mapping keys to ranks (can be empty)
# Create singular values for two components
D = {
'component_1': np.array([10.0, 5.0, 2.0, 0.5, 0.1]),
'component_2': np.array([8.0, 4.0, 1.5, 0.3])
}
# Create left singular basis vectors matching dimensions
# For component_1: 5 modes (from D), so shape (n_samples, 5)
# For component_2: 4 modes (from D), so shape (m_samples, 4)
U = {
'component_1': np.random.randn(7, 5),
'component_2': np.random.randn(6, 4)
}
# Energy capture threshold
eng_cap = 0.999999
# User-specified ranks (empty dict to use energy-based truncation)
user_rank = {}
ARGS = {
'D': D,
'U': U,
'eng_cap': eng_cap,
'user_rank': user_rank
}
- 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
|
| init_cond_onl |
Ran ran; our contract draft was wrong, not the code |
erdc/pynirom/pynirom/rbf/rom.py code served (permissive licence) · get_code("8408470eb905f774") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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 test data
np.random.seed(0)
# Define n_pod: dict mapping solution names to number of POD modes
n_pod = {
'u': 3,
'v': 2
}
# Define snap_data: dict mapping solution names to snapshot matrices
# Shape: (spatial_dim, n_snapshots)
snap_data = {
'u': np.random.randn(5, 10), # 5 spatial points, 10 snapshots
'v': np.random.randn(4, 10) # 4 spatial points, 10 snapshots
}
# Define U: list of POD basis matrices
# U[i] has shape (spatial_dim_i, n_pod_i)
U = [
np.random.randn(5, 3), # For 'u': 5 spatial dims, 3 POD modes
np.random.randn(4, 2) # For 'v': 4 spatial dims, 2 POD modes
]
# Define Smean: dict mapping solution names to mean snapshots
Smean = {
'u': np.random.randn(5), # Mean of 5 spatial points
'v': np.random.randn(4) # Mean of 4 spatial points
}
# Define other parameters
nt_online = 8 # Number of online time steps
t0_ind = 0 # Initial time index
ARGS = {
'snap_data': snap_data,
'nt_online': nt_online,
'n_pod': n_pod,
'U': U,
'Smean': Smean,
't0_ind': t0_ind
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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
|
| prepare_data |
Ran ran on a synthesized input |
erdc/pynirom/pynirom/utils/data_utils.py code served (permissive licence) · get_code("265d0246506b1b71") 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
# Create sample data dictionary with time and solution fields
time_array = np.array([0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
data = {
'time': time_array,
'u': np.random.randn(5, len(time_array)), # 5 spatial points, 10 time steps
'v': np.random.randn(5, len(time_array)), # 5 spatial points, 10 time steps
}
soln_names = ['u', 'v']
options = {
'start_skip': 1,
'end_skip': 9,
'T_start': 0.1,
'T_end': 0.8,
'incr': 2,
}
ARGS = {
'data': data,
'soln_names': soln_names,
'options': options,
}
- 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
|
| project_onto_basis |
Ran ran; our contract draft was wrong, not the code |
erdc/node_nirom/notebooks/node_cylinder.py code served (permissive licence) · get_code("badc48beb2854cec") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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 numpy as np
# Set random seed for reproducibility
np.random.seed(0)
# Create small test data
# S: Dict of high-dimensional snapshots for each component
# Each snapshot matrix has shape (spatial_dim, num_snapshots)
S = {
'p': np.random.randn(4, 2), # 4 spatial points, 2 snapshots
'v_x': np.random.randn(5, 2), # 5 spatial points, 2 snapshots
'v_y': np.random.randn(6, 2), # 6 spatial points, 2 snapshots
}
# Phi: Dict of POD basis vectors for each component
# Each basis matrix has shape (spatial_dim, num_modes)
Phi = {
'p': np.random.randn(4, 3), # 4 spatial points, 3 POD modes
'v_x': np.random.randn(5, 3), # 5 spatial points, 3 POD modes
'v_y': np.random.randn(6, 3), # 6 spatial points, 3 POD modes
}
# Orthonormalize the basis vectors (make them orthonormal)
for key in Phi:
Q, _ = np.linalg.qr(Phi[key])
Phi[key] = Q
# S_mean: Dict of temporal mean for each component
# Each mean vector has shape (spatial_dim,)
S_mean = {
'p': np.random.randn(4), # 4 spatial points
'v_x': np.random.randn(5), # 5 spatial points
'v_y': np.random.randn(6), # 6 spatial points
}
ARGS = {
'S': S,
'Phi': Phi,
'S_mean': S_mean,
'msg': False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- numpy — 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
|
| project_onto_basis |
Ran ran on a synthesized input |
erdc/pynirom/pynirom/pod/pod_utils.py code served (permissive licence) · get_code("fded0b5c3a89c0ff") 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 numpy as np
# Create small sample data for testing
np.random.seed(0)
# Define dimensions:
# - spatial_dim = 4 (high-dimensional space)
# - n_snapshots = 3 (number of temporal snapshots)
# - n_modes = 2 (number of POD basis vectors)
spatial_dim = 4
n_snapshots = 3
n_modes = 2
# Component names
component1 = 'velocity'
component2 = 'pressure'
# S: Dict of high-dimensional snapshots
# Each entry has shape (spatial_dim, n_snapshots)
S = {
component1: np.random.randn(spatial_dim, n_snapshots),
component2: np.random.randn(spatial_dim, n_snapshots)
}
# Phi: Dict of POD basis vectors (orthonormal bases)
# Each entry has shape (spatial_dim, n_modes)
Phi = {
component1: np.random.randn(spatial_dim, n_modes),
component2: np.random.randn(spatial_dim, n_modes)
}
# Orthonormalize the basis vectors using QR decomposition
for key in Phi.keys():
Q, R = np.linalg.qr(Phi[key])
Phi[key] = Q[:, :n_modes]
# S_mean: Dict of temporal mean for each component
# Each entry has shape (spatial_dim,)
S_mean = {
component1: np.mean(S[component1], axis=1),
component2: np.mean(S[component2], axis=1)
}
# msg parameter
msg = False
ARGS = {
'S': S,
'Phi': Phi,
'S_mean': S_mean,
'msg': msg
}
- 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 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
|
| scale_states |
Ran ran on a synthesized input |
erdc/pynirom/pynirom/node/node.py code served (permissive licence) · get_code("a6e03e31ed6fc434") 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
from sklearn.preprocessing import MinMaxScaler, StandardScaler, MaxAbsScaler
# Create a small 2D numpy array (Time X State)
# Shape: 5 time steps, 3 state dimensions
state_array = np.array([
[1.0, 2.0, 3.0],
[2.0, 3.0, 4.0],
[3.0, 4.0, 5.0],
[4.0, 5.0, 6.0],
[5.0, 6.0, 7.0]
], dtype=np.float32)
ARGS = {
'state_array': state_array,
'method': 'centered'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn — 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
|
| scale_time |
Ran ran on a synthesized input |
erdc/pynirom/pynirom/node/node.py code served (permissive licence) · get_code("a6abed9452167983") 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
# Create a small time array from 0 to T
time_array = np.linspace(0, 10, 11) # 11 points from 0 to 10
# Create options dict with optional tscale parameter
options = {
'tscale': 5.0
}
ARGS = {
'time_array': time_array,
'options': options
}
- 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
|
| viz_err |
Ran ran on a synthesized input |
erdc/pynirom/pynirom/rbf/plotting.py code served (permissive licence) · get_code("cb305b0b881c14b0") 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 PolyCollection. 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
import matplotlib.pyplot as plt
torch.manual_seed(0)
# Create small test data for a finite element mesh
# nodes: coordinates of mesh nodes (N x 2)
nodes = np.array([
[0.0, 0.0],
[1.0, 0.0],
[0.5, 1.0],
[0.0, 1.0]
], dtype=np.float32)
# triangles: connectivity indices (M x 3)
triangles = np.array([
[0, 1, 2],
[0, 2, 3]
], dtype=np.int32)
# uh: NIROM solution values at nodes (N,)
uh = np.array([0.1, 0.2, 0.15, 0.05], dtype=np.float32)
# snap: snapshot/reference solution values at nodes (N,)
snap = np.array([0.12, 0.18, 0.14, 0.08], dtype=np.float32)
ARGS = {
"uh": uh,
"snap": snap,
"nodes": nodes,
"triangles": triangles
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type PolyCollection — a PolyCollection output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a PolyCollection 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
|
| viz_sol |
Ran ran on a synthesized input |
erdc/pynirom/pynirom/rbf/plotting.py code served (permissive licence) · get_code("31499761d8eeab82") 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 matplotlib.pyplot as plt
# Create small synthetic data for visualization
np.random.seed(0)
# Create nodes: 2D coordinates for mesh vertices
# Shape: (num_nodes, 2)
num_nodes = 6
nodes = np.array([
[0.0, 0.0],
[1.0, 0.0],
[1.0, 1.0],
[0.0, 1.0],
[0.5, 0.5],
[0.25, 0.75]
], dtype=np.float64)
# Create triangles: indices into nodes array
# Shape: (num_triangles, 3)
triangles = np.array([
[0, 1, 4],
[1, 2, 4],
[2, 3, 4],
[3, 0, 4],
[0, 4, 5],
[3, 5, 4]
], dtype=np.int32)
# Create solution values at each node
# Shape: (num_nodes,)
uh = np.array([0.1, 0.5, 0.9, 0.3, 0.6, 0.2], dtype=np.float64)
ARGS = {
'uh': uh,
'nodes': nodes,
'triangles': triangles
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, 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
|
| combine_L |
Not yet run unverified (harvested, no recorded run) |
erdc/pynirom/pynirom/rbf/greedy.py code served (permissive licence) · get_code("aa03d22e70261b8e") How it ran |
| greedy |
Not yet run unverified (harvested, no recorded run) |
erdc/pynirom/pynirom/rbf/greedy.py code served (permissive licence) · get_code("163ff6791fabf8ca") How it ran |