Skip to content

Commit 1e451ea

Browse files
facelessuserfacelessuser
authored
Update coloraide to 1.7 (#245)
1 parent 7c8b4ce commit 1e451ea

33 files changed

+1461
-162
lines changed

‎lib/coloraide/__meta__.py‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -192,5 +192,5 @@ def parse_version(ver: str) -> Version:
192192
return Version(major, minor, micro, release, pre, post, dev)
193193

194194

195-
__version_info__ = Version(1, 5, 0, "final")
195+
__version_info__ = Version(1, 7, 0, "final")
196196
__version__ = __version_info__._get_canonical()

‎lib/coloraide/algebra.py‎

Lines changed: 119 additions & 113 deletions
Original file line numberDiff line numberDiff line change
@@ -158,6 +158,12 @@ def npow(base: float, exp: float) -> float:
158158
return math.copysign(abs(base) ** exp, base)
159159

160160

161+
def nlog(value: float) -> float:
162+
"""Perform `log` with a negative number."""
163+
164+
return math.copysign(1, value) * math.log(abs(value))
165+
166+
161167
################################
162168
# Interpolation and splines
163169
################################
@@ -502,12 +508,12 @@ def cross(a: VectorLike, b: VectorLike) -> Vector:
502508

503509

504510
@overload
505-
def cross(a: MatrixLike, b: Union[VectorLike, MatrixLike]) -> Matrix:
511+
def cross(a: MatrixLike, b: Any) -> Matrix:
506512
...
507513

508514

509515
@overload
510-
def cross(a: Union[VectorLike, MatrixLike], b: MatrixLike) -> Matrix:
516+
def cross(a: Any, b: MatrixLike) -> Matrix:
511517
...
512518

513519

@@ -859,47 +865,57 @@ def _vector_math(op: Callable[..., float], a: VectorLike, b: VectorLike) -> Vect
859865

860866

861867
@overload
862-
def _math(op: Callable[..., float], a: float, b: float, *, dims: Optional[Tuple[int, int]] = None) -> float:
863-
...
864-
865-
866-
@overload
867-
def _math(op: Callable[..., float], a: float, b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
868-
...
869-
870-
871-
@overload
872-
def _math(op: Callable[..., float], a: VectorLike, b: float, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
873-
...
874-
875-
876-
@overload
877-
def _math(op: Callable[..., float], a: float, b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
878-
...
879-
880-
881-
@overload
882-
def _math(op: Callable[..., float], a: MatrixLike, b: float, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
868+
def _math(
869+
op: Callable[..., float],
870+
a: float,
871+
b: float,
872+
*,
873+
dims: Optional[Tuple[int, int]] = None
874+
) -> float:
883875
...
884876

885877

886878
@overload
887-
def _math(op: Callable[..., float], a: VectorLike, b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
879+
def _math(
880+
op: Callable[..., float],
881+
a: Union[float, VectorLike],
882+
b: VectorLike,
883+
*,
884+
dims: Optional[Tuple[int, int]] = None
885+
) -> Vector:
888886
...
889887

890888

891889
@overload
892-
def _math(op: Callable[..., float], a: VectorLike, b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
890+
def _math(
891+
op: Callable[..., float],
892+
a: VectorLike,
893+
b: Union[float, VectorLike],
894+
*,
895+
dims: Optional[Tuple[int, int]] = None
896+
) -> Vector:
893897
...
894898

895899

896900
@overload
897-
def _math(op: Callable[..., float], a: MatrixLike, b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
901+
def _math(
902+
op: Callable[..., float],
903+
a: MatrixLike,
904+
b: Union[float, ArrayLike],
905+
*,
906+
dims: Optional[Tuple[int, int]] = None
907+
) -> Matrix:
898908
...
899909

900910

901911
@overload
902-
def _math(op: Callable[..., float], a: MatrixLike, b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
912+
def _math(
913+
op: Callable[..., float],
914+
a: Union[ArrayLike, float],
915+
b: MatrixLike,
916+
*,
917+
dims: Optional[Tuple[int, int]] = None
918+
) -> Matrix:
903919
...
904920

905921

@@ -995,42 +1011,22 @@ def divide(a: float, b: float, *, dims: Optional[Tuple[int, int]] = None) -> flo
9951011

9961012

9971013
@overload
998-
def divide(a: float, b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
999-
...
1000-
1001-
1002-
@overload
1003-
def divide(a: VectorLike, b: float, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
1014+
def divide(a: Union[float, VectorLike], b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
10041015
...
10051016

10061017

10071018
@overload
1008-
def divide(a: float, b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1019+
def divide(a: VectorLike, b: Union[float, VectorLike], *, dims: Optional[Tuple[int, int]] = None) -> Vector:
10091020
...
10101021

10111022

10121023
@overload
1013-
def divide(a: MatrixLike, b: float, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1024+
def divide(a: MatrixLike, b: Union[float, ArrayLike], *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
10141025
...
10151026

10161027

10171028
@overload
1018-
def divide(a: VectorLike, b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
1019-
...
1020-
1021-
1022-
@overload
1023-
def divide(a: VectorLike, b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1024-
...
1025-
1026-
1027-
@overload
1028-
def divide(a: MatrixLike, b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1029-
...
1030-
1031-
1032-
@overload
1033-
def divide(a: MatrixLike, b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1029+
def divide(a: Union[float, ArrayLike], b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
10341030
...
10351031

10361032

@@ -1051,42 +1047,22 @@ def multiply(a: float, b: float, *, dims: Optional[Tuple[int, int]] = None) -> f
10511047

10521048

10531049
@overload
1054-
def multiply(a: float, b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
1055-
...
1056-
1057-
1058-
@overload
1059-
def multiply(a: VectorLike, b: float, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
1050+
def multiply(a: Union[float, VectorLike], b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
10601051
...
10611052

10621053

10631054
@overload
1064-
def multiply(a: float, b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1055+
def multiply(a: VectorLike, b: Union[float, VectorLike], *, dims: Optional[Tuple[int, int]] = None) -> Vector:
10651056
...
10661057

10671058

10681059
@overload
1069-
def multiply(a: MatrixLike, b: float, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1060+
def multiply(a: MatrixLike, b: Union[float, ArrayLike], *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
10701061
...
10711062

10721063

10731064
@overload
1074-
def multiply(a: VectorLike, b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
1075-
...
1076-
1077-
1078-
@overload
1079-
def multiply(a: VectorLike, b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1080-
...
1081-
1082-
1083-
@overload
1084-
def multiply(a: MatrixLike, b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1085-
...
1086-
1087-
1088-
@overload
1089-
def multiply(a: MatrixLike, b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1065+
def multiply(a: Union[float, ArrayLike], b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
10901066
...
10911067

10921068

@@ -1107,42 +1083,22 @@ def add(a: float, b: float, *, dims: Optional[Tuple[int, int]] = None) -> float:
11071083

11081084

11091085
@overload
1110-
def add(a: float, b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
1111-
...
1112-
1113-
1114-
@overload
1115-
def add(a: VectorLike, b: float, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
1086+
def add(a: Union[float, VectorLike], b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
11161087
...
11171088

11181089

11191090
@overload
1120-
def add(a: float, b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1091+
def add(a: VectorLike, b: Union[float, VectorLike], *, dims: Optional[Tuple[int, int]] = None) -> Vector:
11211092
...
11221093

11231094

11241095
@overload
1125-
def add(a: MatrixLike, b: float, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1096+
def add(a: MatrixLike, b: Union[float, ArrayLike], *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
11261097
...
11271098

11281099

11291100
@overload
1130-
def add(a: VectorLike, b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
1131-
...
1132-
1133-
1134-
@overload
1135-
def add(a: VectorLike, b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1136-
...
1137-
1138-
1139-
@overload
1140-
def add(a: MatrixLike, b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1141-
...
1142-
1143-
1144-
@overload
1145-
def add(a: MatrixLike, b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1101+
def add(a: Union[float, ArrayLike], b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
11461102
...
11471103

11481104

@@ -1163,54 +1119,104 @@ def subtract(a: float, b: float, *, dims: Optional[Tuple[int, int]] = None) -> f
11631119

11641120

11651121
@overload
1166-
def subtract(a: float, b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
1122+
def subtract(a: Union[float, VectorLike], b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
11671123
...
11681124

11691125

11701126
@overload
1171-
def subtract(a: VectorLike, b: float, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
1127+
def subtract(a: VectorLike, b: Union[float, VectorLike], *, dims: Optional[Tuple[int, int]] = None) -> Vector:
11721128
...
11731129

11741130

11751131
@overload
1176-
def subtract(a: float, b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1132+
def subtract(a: MatrixLike, b: Union[float, ArrayLike], *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
11771133
...
11781134

11791135

11801136
@overload
1181-
def subtract(a: MatrixLike, b: float, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1137+
def subtract(a: Union[float, ArrayLike], b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
11821138
...
11831139

11841140

1141+
def subtract(
1142+
a: Union[float, ArrayLike],
1143+
b: Union[float, ArrayLike],
1144+
*,
1145+
dims: Optional[Tuple[int, int]] = None
1146+
) -> Union[float, Array]:
1147+
"""Subtract simple numbers, vectors, and 2D matrices."""
1148+
1149+
return _math(operator.sub, a, b, dims=dims)
1150+
1151+
11851152
@overload
1186-
def subtract(a: VectorLike, b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Vector:
1153+
def apply(
1154+
fn: Callable[..., float],
1155+
a: float,
1156+
b: Optional[float] = None,
1157+
*,
1158+
dims: Optional[Tuple[int, int]] = None
1159+
) -> float:
1160+
...
1161+
1162+
1163+
@overload
1164+
def apply(
1165+
fn: Callable[..., float],
1166+
a: Union[float, VectorLike],
1167+
b: VectorLike,
1168+
*,
1169+
dims: Optional[Tuple[int, int]] = None
1170+
) -> Vector:
11871171
...
11881172

11891173

11901174
@overload
1191-
def subtract(a: VectorLike, b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1175+
def apply(
1176+
fn: Callable[..., float],
1177+
a: VectorLike,
1178+
b: Optional[Union[float, VectorLike]] = None,
1179+
*,
1180+
dims: Optional[Tuple[int, int]] = None
1181+
) -> Vector:
11921182
...
11931183

11941184

11951185
@overload
1196-
def subtract(a: MatrixLike, b: VectorLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1186+
def apply(
1187+
fn: Callable[..., float],
1188+
a: MatrixLike,
1189+
b: Optional[Union[float, ArrayLike]] = None,
1190+
*,
1191+
dims: Optional[Tuple[int, int]] = None
1192+
) -> Matrix:
11971193
...
11981194

11991195

12001196
@overload
1201-
def subtract(a: MatrixLike, b: MatrixLike, *, dims: Optional[Tuple[int, int]] = None) -> Matrix:
1197+
def apply(
1198+
fn: Callable[..., float],
1199+
a: Union[float, ArrayLike],
1200+
b: MatrixLike,
1201+
*,
1202+
dims: Optional[Tuple[int, int]] = None
1203+
) -> Matrix:
12021204
...
12031205

12041206

1205-
def subtract(
1207+
def apply(
1208+
fn: Callable[..., float],
12061209
a: Union[float, ArrayLike],
1207-
b: Union[float, ArrayLike],
1210+
b: Optional[Union[float, ArrayLike]] = None,
12081211
*,
12091212
dims: Optional[Tuple[int, int]] = None
12101213
) -> Union[float, Array]:
1211-
"""Subtract simple numbers, vectors, and 2D matrices."""
1214+
"""Apply a given function over each element of the matrix."""
12121215

1213-
return _math(operator.sub, a, b, dims=dims)
1216+
if b is None:
1217+
return reshape([fn(f) for f in flatiter(a)], shape(a))
1218+
1219+
return _math(fn, a, b, dims=dims)
12141220

12151221

12161222
class BroadcastTo:
@@ -1777,7 +1783,7 @@ def diag(array: VectorLike, k: int = 0) -> Matrix:
17771783

17781784

17791785
@overload
1780-
def diag(array: Matrix, k: int = 0) -> Vector:
1786+
def diag(array: MatrixLike, k: int = 0) -> Vector:
17811787
...
17821788

17831789

@@ -1871,7 +1877,7 @@ def inv(matrix: MatrixLike) -> Matrix:
18711877
m = acopy(matrix)
18721878

18731879
# Create an identity matrix of the same size as our provided vector
1874-
im = diag([1] * s[0])
1880+
im = identity(s[0])
18751881

18761882
# Iterating through each row, we will scale each row by it's "focus diagonal".
18771883
# Then using the scaled row, we will adjust the other rows.

0 commit comments

Comments
 (0)