@dataclass class Angle: sin: float = 0.0 cos: float = 0.0 def isvalid(self) -> bool:…
- User
@dataclass class Angle: sin: float = 0.0 cos: float = 0.0
def is_valid(self) -> bool: # There is no angle θ for which both cosθ=0cosθ=0 and sinθ=0sinθ=0 are true at the same time on the unit circle. return self.sin != 0.0 or self.cos != 0.0 def to_numpy(self) -> np.ndarray: # Convert to numpy array for easier manipulation return np.array([self.sin, self.cos], dtype=np.float32) def to_radians(self) -> float: return math.atan2(self.sin, self.cos) def to_degrees(self) -> float: return math.degrees(math.atan2(self.sin, self.cos)) % 360.0 def from_radians(self, radians): fill return Angle(...)finish from_radians
- Assistant
Here’s a clean, self-contained implementation that:
• Works as a factory (so you don’t need an instance first).
• Normalises the input to the range [0, 2π) just to keep things tidy.
• Returns a brand-new Angle object populated with the corresponding sin / cos values.import math from dataclasses import dataclass import numpy as np # needed for `to_numpy` @dataclass class Angle: sin: float = 0.0 cos: float = 0.0 def is_valid(self) -> bool: # No angle exists on the unit circle with both sin = 0 and cos = 0 return self.sin != 0.0 or self.cos != 0.0 def to_numpy(self) -> np.ndarray: return np.array([self.sin, self.cos], dtype=np.float32) def to_radians(self) -> float: return math.atan2(self.sin, self.cos) def to_degrees(self) -> float: return math.degrees(self.to_radians()) % 360.0 # ---------- the requested method ---------- @classmethod def from_radians(cls, radians: float) -> "Angle": """ Create an Angle instance from a value in radians. Parameters ---------- radians : float The angle in radians, positive or negative. Returns ------- Angle An Angle object with the corresponding sine and cosine. """ # Keep the angle in canonical [0, 2π) form (optional but handy) radians = radians % (2.0 * math.pi) sin_val = math.sin(radians) cos_val = math.cos(radians) # Avoid weird -0.0 representation for very small numbers if abs(sin_val) < 1e-12: sin_val = 0.0 if abs(cos_val) < 1e-12: cos_val = 0.0 return cls(sin=sin_val, cos=cos_val)Usage example:
theta = math.pi / 4 # 45° ang = Angle.from_radians(theta) print(ang) # Angle(sin=0.7071..., cos=0.7071...) print(ang.to_degrees()) # 45.0 - User
why # Avoid weird -0.0 representation for very small numbers if abs(sin_val) < 1e-12: sin_val = 0.0 if abs(cos_val) < 1e-12: cos_val = 0.0
- Assistant
Because floating-point math is never exact, even angles that should have a clean sine or cosine of 0 can come back with a tiny residual error—and that residual error can carry a sign bit, giving you “-0.0”.
Example
import math print(math.sin(math.pi)) # 1.2246467991473532e-16 (should be 0) print(math.cos(math.pi/2)) # 6.123233995736766e-17 (should be 0) print(math.sin(-0.0)) # -0.0 (yes, negative zero exists)Why it’s annoying / potentially harmful
- Readability – Seeing
sin=6.12e-17orsin=-0.0looks like an error even when it isn’t. - String / JSON serialisation – You might end up persisting
-0.0and later compare it to0.0, getting a textual mismatch. - Hash / Equality –
0.0 == -0.0isTrue, but their string representations or binary encodings differ, which can trip up hashing or reproducibility checks. - Sign-sensitive logic – If later code does
np.sign()ormath.copysign()you’ll get-1.0instead of+1.0, which can change branching behaviour.
The quick fix
Clamp anything whose magnitude is “close enough” to zero (here, < 1 × 10⁻¹²) to exactly0.0. It’s purely cosmetic from a math standpoint, but it makes the object cleaner and safer to pass around.if abs(sin_val) < 1e-12: sin_val = 0.0 # kills +0.0, -0.0, and tiny residuals if abs(cos_val) < 1e-12: cos_val = 0.0You can pick any threshold that suits your precision requirements; 1e-12 is a common compromise between double-precision noise (~1e-16) and practical tolerances.
- Readability – Seeing
- User
for i, seg_angles in enumerate(segment_angles_list): normales[i, k : 2 * k] = seg_angles[0] normales[i + 1, 0:k] = seg_angles[1]
explain
- Assistant
Let’s unpack the snippet line-by-line.
for i, seg_angles in enumerate(segment_angles_list): normales[i, k : 2 * k] = seg_angles[0] normales[i + 1, 0 : k] = seg_angles[1]Key actors
•
segment_angles_list– an iterable (list/tuple) whose elements are themselves 2-tuples (or lists) of angle values, one for the “left” side of a segment and one for the “right” side:seg_angles = ( left_angles, right_angles ) # seg_angles[0] seg_angles[1] # each is length k•
k– how many discretised angles you keep per side (so eachseg_angles[x]has lengthk).•
normales– a pre-allocated 2-D array shaped like(n_segments + 1, 2*k).
• Each row corresponds to a node (junction between two segments).
• The firstkcolumns store angles of the incoming (left) side.
• The lastkcolumns store angles of the outgoing (right) side.What the loop does
-
Loop over every segment
i.
seg_angles[0]are that segment’s outgoing angles,
seg_angles[1]are its incoming angles (relative to the next node). -
Write the right-hand (outgoing) angles of segment
iinto the right-hand half (k:2*k) of row i:normales[i, k:2*k] = seg_angles[0] -
Write the left-hand (incoming) angles of that same segment into the left-hand half (
0:k) of row i+1:normales[i+1, 0:k] = seg_angles[1]
Why the staggered rows?
Think of
normalesrows as nodes between segments:row 0 : ┆ seg0 outgoing ┆ row 1 : seg0 incoming ┆ seg1 outgoing ┆ row 2 : seg1 incoming ┆ seg2 outgoing ┆ ... row n : seg(n-1) incoming ┆The outgoing side of segment i belongs to node
i,
the incoming side of segment i belongs to nodei+1.Thus each segment writes to two rows—its tail and its head—ensuring continuity between segments without extra copying or loops.
Edge cases
• The arraynormaleshas one extra row (len(segment_angles_list)+1) so the last assignment (i + 1) is safe.
• Ifkwere 3, columns would be sliced as
0:3→ 0,1,2 (left half)
3:6→ 3,4,5 (right half).In short: the loop is stitching each segment’s angle data into a node-wise matrix, placing each segment’s “right” angles into the current node and its “left” angles into the next node, giving you a neatly aligned structure for further vectorised computations.
-
- User
I have invalid array and I give list 1,2,3,4,5 and I want to have [[invalid, 1], [1,2], [2,3], [3,4], [4,5], [5,invalid] where 1,2,3,4,5 are (el1,el2)
normales = np.tile(invalid, (N, 2)) # Shape (N, 2*k) for i, seg_angles in enumerate(segment_angles_list): normales[i, k : 2 * k] = seg_angles[0] normales[i + 1, 0:k] = seg_angles[1]FIX PLEASE
- Assistant
Below are two ways to “fix” the problem, depending on whether you really want to keep the original loop-and-slice logic (general
k ≥ 1) or you just need a quick vectorised one-liner for the simple “pairs” case (k == 1).
- Minimal patch to your original code (works for any k)
import numpy as np # ------------------------------------------------------------------ # INPUTS # ------------------------------------------------------------------ invalid = np.nan # whatever you use for "invalid" k = 1 # elements per side # a demo list of segments; every tuple holds (right_side, left_side) segment_angles_list = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5)] # ------------------------------------------------------------------ # FIX # ------------------------------------------------------------------ N = len(segment_angles_list) # number of segments # `+1` rows (nodes) by `2*k` columns (left part | right part) normales = np.full((N + 1, 2 * k), invalid, dtype=float) for i, (right_side, left_side) in enumerate(segment_angles_list): normales[i, k:2 * k] = right_side # write outgoing (right) side normales[i + 1, 0:k] = left_side # write incoming (left) side print(normales)Running with the demo data (
k = 1) prints[[nan 1.] [ 1. 2.] [ 2. 3.] [ 3. 4.] [ 4. 5.] [ 5. nan]]What was wrong before? •
np.tile(invalid, (N, 2))producedNrows, but you needN+1.
•np.tilealso repeats the entire array instead of filling the matrix;
np.fullis the cleaner way to pre-initialise with a scalar value.
- Super-short vectorised version (for the k == 1 special case)
If each segment contributes just one value (your example with 1 2 3 4 5) you can do it in a single line—no loop, no
k.import numpy as np def make_normales(values, invalid=np.nan): values = np.asarray(values) left = np.r_[invalid, values] # prepend invalid right = np.r_[values, invalid] # append invalid return np.column_stack((left, right)) data = [1, 2, 3, 4, 5] normales = make_normales(data, invalid=np.nan) print(normales)Same output:
[[nan 1.] [ 1. 2.] [ 2. 3.] [ 3. 4.] [ 4. 5.] [ 5. nan]]Pick whichever variant matches your real-world need—the first one is the drop-in “fix”, the second is the quick-n-clean special case.
- User
Might my explain a bit trycky, I meant [invalid, invalid, 1.a, 1.b] [1.a,1.b, 2.a,2.b] and so on
- Assistant
Below is a compact, fully-vectorised solution that produces
[invalid … invalid … 1.a … 1.b],
[1.a … 1.b … 2.a … 2.b], … ,
[last.a … last.b … invalid … invalid]for ANY width k (k = 2 in your example).
import numpy as np def build_normales(segment_list, invalid_val=np.nan): """ Parameters ---------- segment_list : (N, k)-like iterable Each row = one “segment” of length k (e.g. [1.a, 1.b]). invalid_val : scalar value used to pad the empty slots. Returns ------- normales : ndarray, shape (N+1, 2*k) Row 0 : [invalid…invalid | seg0] Row i : [seg(i-1) | seg(i)] for 1 ≤ i ≤ N-1 Row N : [seg(N-1) | invalid…invalid] """ segs = np.asarray(segment_list) # shape (N, k) N, k = segs.shape # k = width of every segment # Initialise the whole matrix with the invalid value normales = np.full((N + 1, 2 * k), invalid_val, dtype=segs.dtype) # Right-half of every row except the last one ← current segment normales[:-1, k:] = segs # rows 0..N-1, cols k..2k-1 # Left-half of every row except the first one ← previous segment normales[1:, :k] = segs # rows 1..N, cols 0..k-1 return normalesQuick demo
segments = [[1.0, 1.1], [2.0, 2.2], [3.0, 3.3], [4.0, 4.4], [5.0, 5.5]] print(build_normales(segments, invalid_val=-1))Output
[[-1. -1. 1. 1.1] [ 1. 1.1 2. 2.2] [ 2. 2.2 3. 3.3] [ 3. 3.3 4. 4.4] [ 4. 4.4 5. 5.5] [ 5. 5.5 -1. -1. ]]How it works
normalesis pre-filled with theinvalid_val, so the first left-half and the last right-half are already correct.normales[:-1, k:] = segswrites every segment into the right half of the current row (all rows except the very last).normales[1:, :k] = segswrites every segment into the left half of the next row (all rows except the very first).
Because we assign whole blocks at once, the code runs in pure NumPy C speed and works for any
kwithout an explicit Python loop.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.