Integer vector cross products
VectorAnvil keeps vector routines and an AI conversation in one Windows coding workspace. Select a compatible model, inspect its proposed cross-product edits, and verify that swapping the inputs reverses the orientation.
def cross_product(a, b):
if type(a) not in (list, tuple) or type(b) not in (list, tuple):
raise ValueError("vector.type")
if len(a) != 3 or len(b) != 3 or any(type(x) is not int for x in (*a, *b)):
raise ValueError("vector.components")
x, y, z = a
u, v, w = b
return (y*w-z*v, z*u-x*w, x*v-y*u)| Review before applying | Compare actual behavior with the expected result. If a check fails, investigate it before applying more changes. |
|---|---|
| Connection | Base URL, credentials and a reachable server. |
| Project | Check parallel vectors, basis order and large coordinates, rejecting wrong lengths and non-integer components without changing either input. |
def cross_product(a, b):
if type(a) not in (list, tuple) or type(b) not in (list, tuple):
raise ValueError("vector.type")
if len(a) != 3 or len(b) != 3 or any(type(x) is not int for x in (*a, *b)):
raise ValueError("vector.components")
x, y, z = a
u, v, w = b
return (y*w-z*v, z*u-x*w, x*v-y*u)Make orientation assumptions visible before editing
VectorAnvil gives developers a Windows workspace for source inspection, coding conversations and proposed changes with a connected model. For numerical code, begin with the convention the rest of the application relies on. A correct-looking expression can still be the wrong change if the caller interprets its output in a different coordinate system.
One task is to review a right-handed cross-product routine for three-component integer vectors. Bring its callers and type assumptions into the conversation, then ask how input order affects the result. State whether the routine must leave both inputs unchanged. This gives the model a specific maintenance problem without treating a mathematical example as a built-in application feature.
Evaluate the proposal with basis-vector and parallel-vector fixtures in your own project. Reverse the input order and inspect whether the orientation follows the stated convention. Include large coordinates if they are relevant to your data types, and check the rejection path for malformed input. Review what changed at the call sites as carefully as the routine itself.
Select a model through a supported OpenAI-compatible or Anthropic endpoint. If that endpoint provides unfiltered AI models, VectorAnvil can use the supported connection with required credentials. The chosen model and server determine response restrictions, tools and context limits; your project's conventions remain the standard for accepting the result.
Questions for a vector-code review
What convention should I put in the request?
State the coordinate convention, expected input order and component types used by your application. Include one known result from the existing contract. That anchors the discussion and makes it easier to spot a proposal that silently reverses orientation.
Why compare the swapped inputs?
For this example, swapping the two vectors should reverse the cross-product orientation. Use a fixture with a nonzero result so the check is meaningful. Inspect the calling code too, because argument order there determines the convention actually used.
Should parallel vectors cause an error?
Describe your application's policy rather than let the proposal invent one. A zero result may be valid for the routine while requiring special handling by a later consumer. Include that consumer if its behavior is part of the requested change.
Can I broaden the routine to other numeric types?
Treat that as a separate contract change with explicit accepted types and verification cases. The integer-vector example does not establish suitable floating-point or overflow behavior for your application. Review the real types and run the project's relevant checks.
VectorAnvil · Updated 2026-10-25