diff --git a/palette/src/alpha.rs b/palette/src/alpha.rs
index 101130b8a..d897a62a3 100644
--- a/palette/src/alpha.rs
+++ b/palette/src/alpha.rs
@@ -1,4 +1,4 @@
-use core::ops::{Add, Deref, DerefMut, Div, Mul, Sub};
+use core::ops::{Add, AddAssign, Deref, DerefMut, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
 use core::fmt;
 
 use float::Float;
@@ -237,6 +237,20 @@ impl<T: Add + Clone, C: Add<T>> Add<T> for Alpha<C, T> {
     }
 }
 
+impl<C: AddAssign, T: Float + AddAssign> AddAssign for Alpha<C, T> {
+    fn add_assign(&mut self, other: Alpha<C, T>) {
+        self.color += other.color;
+        self.alpha += other.alpha;
+    }
+}
+
+impl<T: AddAssign + Copy, C: AddAssign<T>> AddAssign<T> for Alpha<C, T> {
+    fn add_assign(&mut self, c: T) {
+        self.color += c;
+        self.alpha += c;
+    }
+}
+
 impl<C: Sub, T: Float> Sub for Alpha<C, T> {
     type Output = Alpha<C::Output, <T as Sub>::Output>;
 
@@ -259,6 +273,20 @@ impl<T: Sub + Clone, C: Sub<T>> Sub<T> for Alpha<C, T> {
     }
 }
 
+impl<C: SubAssign, T: Float + SubAssign> SubAssign for Alpha<C, T> {
+    fn sub_assign(&mut self, other: Alpha<C, T>) {
+        self.color -= other.color;
+        self.alpha -= other.alpha;
+    }
+}
+
+impl<T: SubAssign + Copy, C: SubAssign<T>> SubAssign<T> for Alpha<C, T> {
+    fn sub_assign(&mut self, c: T) {
+        self.color -= c;
+        self.alpha -= c;
+    }
+}
+
 impl<C: Mul, T: Float> Mul for Alpha<C, T> {
     type Output = Alpha<C::Output, <T as Mul>::Output>;
 
@@ -281,6 +309,20 @@ impl<T: Mul + Clone, C: Mul<T>> Mul<T> for Alpha<C, T> {
     }
 }
 
+impl<C: MulAssign, T: Float + MulAssign> MulAssign for Alpha<C, T> {
+    fn mul_assign(&mut self, other: Alpha<C, T>) {
+        self.color *= other.color;
+        self.alpha *= other.alpha;
+    }
+}
+
+impl<T: MulAssign + Copy, C: MulAssign<T>> MulAssign<T> for Alpha<C, T> {
+    fn mul_assign(&mut self, c: T) {
+        self.color *= c;
+        self.alpha *= c;
+    }
+}
+
 impl<C: Div, T: Float> Div for Alpha<C, T> {
     type Output = Alpha<C::Output, <T as Div>::Output>;
 
@@ -303,6 +345,20 @@ impl<T: Div + Clone, C: Div<T>> Div<T> for Alpha<C, T> {
     }
 }
 
+impl<C: DivAssign, T: Float + DivAssign> DivAssign for Alpha<C, T> {
+    fn div_assign(&mut self, other: Alpha<C, T>) {
+        self.color /= other.color;
+        self.alpha /= other.alpha;
+    }
+}
+
+impl<T: DivAssign + Copy, C: DivAssign<T>> DivAssign<T> for Alpha<C, T> {
+    fn div_assign(&mut self, c: T) {
+        self.color /= c;
+        self.alpha /= c;
+    }
+}
+
 impl<C, T, P> AsRef<P> for Alpha<C, T>
 where
     C: Pixel<T>,
diff --git a/palette/src/blend/pre_alpha.rs b/palette/src/blend/pre_alpha.rs
index 43569f657..2d103d511 100644
--- a/palette/src/blend/pre_alpha.rs
+++ b/palette/src/blend/pre_alpha.rs
@@ -1,4 +1,4 @@
-use core::ops::{Add, Deref, DerefMut, Div, Mul, Sub};
+use core::ops::{Add, AddAssign, Deref, DerefMut, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
 use approx::{AbsDiffEq, RelativeEq, UlpsEq};
 use float::Float;
 
@@ -197,7 +197,7 @@ where
 impl<C: Add, T: Float> Add for PreAlpha<C, T> {
     type Output = PreAlpha<C::Output, T>;
 
-    fn add(self, other: PreAlpha<C, T>) -> PreAlpha<C::Output, T> {
+    fn add(self, other: PreAlpha<C, T>) -> Self::Output {
         PreAlpha {
             color: self.color + other.color,
             alpha: self.alpha + other.alpha,
@@ -208,7 +208,7 @@ impl<C: Add, T: Float> Add for PreAlpha<C, T> {
 impl<T: Float, C: Add<T>> Add<T> for PreAlpha<C, T> {
     type Output = PreAlpha<C::Output, T>;
 
-    fn add(self, c: T) -> PreAlpha<C::Output, T> {
+    fn add(self, c: T) -> Self::Output {
         PreAlpha {
             color: self.color + c,
             alpha: self.alpha + c,
@@ -216,10 +216,24 @@ impl<T: Float, C: Add<T>> Add<T> for PreAlpha<C, T> {
     }
 }
 
+impl<C: AddAssign , T: Float + AddAssign> AddAssign for PreAlpha<C, T> {
+    fn add_assign(&mut self, other: PreAlpha<C, T>) {
+        self.color += other.color;
+        self.alpha += other.alpha;
+    }
+}
+
+impl<T: Float + AddAssign, C: AddAssign<T>> AddAssign<T> for PreAlpha<C, T> {
+    fn add_assign(&mut self, c: T) {
+        self.color += c;
+        self.alpha += c;
+    }
+}
+
 impl<C: Sub, T: Float> Sub for PreAlpha<C, T> {
     type Output = PreAlpha<C::Output, T>;
 
-    fn sub(self, other: PreAlpha<C, T>) -> PreAlpha<C::Output, T> {
+    fn sub(self, other: PreAlpha<C, T>) -> Self::Output {
         PreAlpha {
             color: self.color - other.color,
             alpha: self.alpha - other.alpha,
@@ -230,7 +244,7 @@ impl<C: Sub, T: Float> Sub for PreAlpha<C, T> {
 impl<T: Float, C: Sub<T>> Sub<T> for PreAlpha<C, T> {
     type Output = PreAlpha<C::Output, T>;
 
-    fn sub(self, c: T) -> PreAlpha<C::Output, T> {
+    fn sub(self, c: T) -> Self::Output {
         PreAlpha {
             color: self.color - c,
             alpha: self.alpha - c,
@@ -238,10 +252,25 @@ impl<T: Float, C: Sub<T>> Sub<T> for PreAlpha<C, T> {
     }
 }
 
+impl<C: SubAssign , T: Float + SubAssign> SubAssign for PreAlpha<C, T> {
+    fn sub_assign(&mut self, other: PreAlpha<C, T>) {
+        self.color -= other.color;
+        self.alpha -= other.alpha;
+    }
+}
+
+impl<T: Float + SubAssign, C: SubAssign<T>> SubAssign<T> for PreAlpha<C, T> {
+    fn sub_assign(&mut self, c: T) {
+        self.color -= c;
+        self.alpha -= c;
+    }
+}
+
+
 impl<C: Mul, T: Float> Mul for PreAlpha<C, T> {
     type Output = PreAlpha<C::Output, T>;
 
-    fn mul(self, other: PreAlpha<C, T>) -> PreAlpha<C::Output, T> {
+    fn mul(self, other: PreAlpha<C, T>) -> Self::Output {
         PreAlpha {
             color: self.color * other.color,
             alpha: self.alpha * other.alpha,
@@ -252,7 +281,7 @@ impl<C: Mul, T: Float> Mul for PreAlpha<C, T> {
 impl<T: Float, C: Mul<T>> Mul<T> for PreAlpha<C, T> {
     type Output = PreAlpha<C::Output, T>;
 
-    fn mul(self, c: T) -> PreAlpha<C::Output, T> {
+    fn mul(self, c: T) -> Self::Output {
         PreAlpha {
             color: self.color * c,
             alpha: self.alpha * c,
@@ -260,10 +289,24 @@ impl<T: Float, C: Mul<T>> Mul<T> for PreAlpha<C, T> {
     }
 }
 
+impl<C: MulAssign , T: Float + MulAssign> MulAssign for PreAlpha<C, T> {
+    fn mul_assign(&mut self, other: PreAlpha<C, T>) {
+        self.color *= other.color;
+        self.alpha *= other.alpha;
+    }
+}
+
+impl<T: Float + MulAssign, C: MulAssign<T>> MulAssign<T> for PreAlpha<C, T> {
+    fn mul_assign(&mut self, c: T) {
+        self.color *= c;
+        self.alpha *= c;
+    }
+}
+
 impl<C: Div, T: Float> Div for PreAlpha<C, T> {
     type Output = PreAlpha<C::Output, T>;
 
-    fn div(self, other: PreAlpha<C, T>) -> PreAlpha<C::Output, T> {
+    fn div(self, other: PreAlpha<C, T>) -> Self::Output {
         PreAlpha {
             color: self.color / other.color,
             alpha: self.alpha / other.alpha,
@@ -274,7 +317,7 @@ impl<C: Div, T: Float> Div for PreAlpha<C, T> {
 impl<T: Float, C: Div<T>> Div<T> for PreAlpha<C, T> {
     type Output = PreAlpha<C::Output, T>;
 
-    fn div(self, c: T) -> PreAlpha<C::Output, T> {
+    fn div(self, c: T) -> Self::Output {
         PreAlpha {
             color: self.color / c,
             alpha: self.alpha / c,
@@ -282,6 +325,20 @@ impl<T: Float, C: Div<T>> Div<T> for PreAlpha<C, T> {
     }
 }
 
+impl<C: DivAssign , T: Float + DivAssign> DivAssign for PreAlpha<C, T> {
+    fn div_assign(&mut self, other: PreAlpha<C, T>) {
+        self.color /= other.color;
+        self.alpha /= other.alpha;
+    }
+}
+
+impl<T: Float + DivAssign, C: DivAssign<T>> DivAssign<T> for PreAlpha<C, T> {
+    fn div_assign(&mut self, c: T) {
+        self.color /= c;
+        self.alpha /= c;
+    }
+}
+
 impl<C, T, P> AsRef<P> for PreAlpha<C, T>
 where
     C: Pixel<T>,
diff --git a/palette/src/hsl.rs b/palette/src/hsl.rs
index 7ade6277b..b0256d6de 100644
--- a/palette/src/hsl.rs
+++ b/palette/src/hsl.rs
@@ -3,7 +3,7 @@ use float::Float;
 
 use core::any::TypeId;
 use core::marker::PhantomData;
-use core::ops::{Add, Sub};
+use core::ops::{Add, AddAssign, Sub, SubAssign};
 
 use encoding::pixel::RawPixel;
 use encoding::{Linear, Srgb};
@@ -435,7 +435,7 @@ where
 {
     type Output = Hsl<S, T>;
 
-    fn add(self, other: Hsl<S, T>) -> Hsl<S, T> {
+    fn add(self, other: Hsl<S, T>) -> Self::Output {
         Hsl {
             hue: self.hue + other.hue,
             saturation: self.saturation + other.saturation,
@@ -452,7 +452,7 @@ where
 {
     type Output = Hsl<S, T>;
 
-    fn add(self, c: T) -> Hsl<S, T> {
+    fn add(self, c: T) -> Self::Output {
         Hsl {
             hue: self.hue + c,
             saturation: self.saturation + c,
@@ -462,6 +462,30 @@ where
     }
 }
 
+impl<S, T> AddAssign<Hsl<S, T>> for Hsl<S, T>
+    where
+        T: Component + Float + AddAssign,
+        S: RgbSpace,
+{
+    fn add_assign(&mut self, other: Hsl<S, T>) {
+        self.hue += other.hue;
+        self.saturation += other.saturation;
+        self.lightness += other.lightness;
+    }
+}
+
+impl<S, T> AddAssign<T> for Hsl<S, T>
+    where
+        T: Component + Float + AddAssign,
+        S: RgbSpace,
+{
+    fn add_assign(&mut self, c: T) {
+        self.hue += c;
+        self.saturation += c;
+        self.lightness += c;
+    }
+}
+
 impl<S, T> Sub<Hsl<S, T>> for Hsl<S, T>
 where
     T: Component + Float,
@@ -469,7 +493,7 @@ where
 {
     type Output = Hsl<S, T>;
 
-    fn sub(self, other: Hsl<S, T>) -> Hsl<S, T> {
+    fn sub(self, other: Hsl<S, T>) -> Self::Output {
         Hsl {
             hue: self.hue - other.hue,
             saturation: self.saturation - other.saturation,
@@ -486,7 +510,7 @@ where
 {
     type Output = Hsl<S, T>;
 
-    fn sub(self, c: T) -> Hsl<S, T> {
+    fn sub(self, c: T) -> Self::Output {
         Hsl {
             hue: self.hue - c,
             saturation: self.saturation - c,
@@ -496,6 +520,30 @@ where
     }
 }
 
+impl<S, T> SubAssign<Hsl<S, T>> for Hsl<S, T>
+    where
+        T: Component + Float + SubAssign,
+        S: RgbSpace,
+{
+    fn sub_assign(&mut self, other: Hsl<S, T>) {
+        self.hue -= other.hue;
+        self.saturation -= other.saturation;
+        self.lightness -= other.lightness;
+    }
+}
+
+impl<S, T> SubAssign<T> for Hsl<S, T>
+    where
+        T: Component + Float + SubAssign,
+        S: RgbSpace,
+{
+    fn sub_assign(&mut self, c: T) {
+        self.hue -= c;
+        self.saturation -= c;
+        self.lightness -= c;
+    }
+}
+
 impl<S, T, P> AsRef<P> for Hsl<S, T>
 where
     T: Component + Float,
diff --git a/palette/src/hsv.rs b/palette/src/hsv.rs
index 26fca96ac..fd147f868 100644
--- a/palette/src/hsv.rs
+++ b/palette/src/hsv.rs
@@ -3,7 +3,7 @@ use float::Float;
 
 use core::any::TypeId;
 use core::marker::PhantomData;
-use core::ops::{Add, Sub};
+use core::ops::{Add, AddAssign, Sub, SubAssign};
 
 use encoding::pixel::RawPixel;
 use encoding::{Linear, Srgb};
@@ -446,7 +446,7 @@ where
 {
     type Output = Hsv<S, T>;
 
-    fn add(self, other: Hsv<S, T>) -> Hsv<S, T> {
+    fn add(self, other: Hsv<S, T>) -> Self::Output {
         Hsv {
             hue: self.hue + other.hue,
             saturation: self.saturation + other.saturation,
@@ -463,7 +463,7 @@ where
 {
     type Output = Hsv<S, T>;
 
-    fn add(self, c: T) -> Hsv<S, T> {
+    fn add(self, c: T) -> Self::Output{
         Hsv {
             hue: self.hue + c,
             saturation: self.saturation + c,
@@ -473,6 +473,30 @@ where
     }
 }
 
+impl<S, T> AddAssign<Hsv<S, T>> for Hsv<S, T>
+    where
+        T: Component + Float + AddAssign,
+        S: RgbSpace,
+{
+    fn add_assign(&mut self, other: Hsv<S, T>) {
+        self.hue += other.hue;
+        self.saturation += other.saturation;
+        self.value += other.value;
+    }
+}
+
+impl<S, T> AddAssign<T> for Hsv<S, T>
+    where
+        T: Component + Float + AddAssign,
+        S: RgbSpace,
+{
+    fn add_assign(&mut self, c: T) {
+        self.hue += c;
+        self.saturation += c;
+        self.value += c;
+    }
+}
+
 impl<S, T> Sub<Hsv<S, T>> for Hsv<S, T>
 where
     T: Component + Float,
@@ -480,7 +504,7 @@ where
 {
     type Output = Hsv<S, T>;
 
-    fn sub(self, other: Hsv<S, T>) -> Hsv<S, T> {
+    fn sub(self, other: Hsv<S, T>) -> Self::Output {
         Hsv {
             hue: self.hue - other.hue,
             saturation: self.saturation - other.saturation,
@@ -497,7 +521,7 @@ where
 {
     type Output = Hsv<S, T>;
 
-    fn sub(self, c: T) -> Hsv<S, T> {
+    fn sub(self, c: T) -> Self::Output {
         Hsv {
             hue: self.hue - c,
             saturation: self.saturation - c,
@@ -507,6 +531,30 @@ where
     }
 }
 
+impl<S, T> SubAssign<Hsv<S, T>> for Hsv<S, T>
+    where
+        T: Component + Float + SubAssign,
+        S: RgbSpace,
+{
+    fn sub_assign(&mut self, other: Hsv<S, T>) {
+        self.hue -= other.hue;
+        self.saturation -= other.saturation;
+        self.value -= other.value;
+    }
+}
+
+impl<S, T> SubAssign<T> for Hsv<S, T>
+    where
+        T: Component + Float + SubAssign,
+        S: RgbSpace,
+{
+    fn sub_assign(&mut self, c: T) {
+        self.hue -= c;
+        self.saturation -= c;
+        self.value -= c;
+    }
+}
+
 impl<S, T, P> AsRef<P> for Hsv<S, T>
 where
     T: Component + Float,
diff --git a/palette/src/hues.rs b/palette/src/hues.rs
index 4df9f77cf..b716317f1 100644
--- a/palette/src/hues.rs
+++ b/palette/src/hues.rs
@@ -2,7 +2,7 @@ use float::Float;
 
 use core::f64::consts::PI;
 use core::cmp::PartialEq;
-use core::ops::{Add, Sub};
+use core::ops::{Add, AddAssign, Sub, SubAssign};
 
 use cast;
 
@@ -150,6 +150,34 @@ macro_rules! make_hues {
             }
         }
 
+        impl<T: Float + AddAssign> AddAssign<$name<T>> for $name<T> {
+            #[inline]
+            fn add_assign(&mut self, other: $name<T>) {
+                self.0 += other.0;
+            }
+        }
+
+        impl<T: Float + AddAssign> AddAssign<T> for $name<T> {
+            #[inline]
+            fn add_assign(&mut self, other: T) {
+                self.0 += other;
+            }
+        }
+
+        impl AddAssign<$name<f32>> for f32 {
+            #[inline]
+            fn add_assign(&mut self, other: $name<f32>) {
+                *self += other.0;
+            }
+        }
+
+        impl AddAssign<$name<f64>> for f64 {
+            #[inline]
+            fn add_assign(&mut self, other: $name<f64>){
+                *self += other.0;
+            }
+        }
+
         impl<T: Float> Sub<$name<T>> for $name<T> {
             type Output = $name<T>;
 
@@ -185,6 +213,34 @@ macro_rules! make_hues {
                 $name(self - other.0)
             }
         }
+        
+        impl<T: Float + SubAssign> SubAssign<$name<T>> for $name<T> {
+            #[inline]
+            fn sub_assign(&mut self, other: $name<T>) {
+                self.0 -= other.0;
+            }
+        }
+
+        impl<T: Float + SubAssign> SubAssign<T> for $name<T> {
+            #[inline]
+            fn sub_assign(&mut self, other: T) {
+                self.0 -= other;
+            }
+        }
+
+        impl SubAssign<$name<f32>> for f32 {
+            #[inline]
+            fn sub_assign(&mut self, other: $name<f32>) {
+                *self -= other.0;
+            }
+        }
+
+        impl SubAssign<$name<f64>> for f64 {
+            #[inline]
+            fn sub_assign(&mut self, other: $name<f64>){
+                *self -= other.0;
+            }
+        }
     )+)
 }
 
diff --git a/palette/src/hwb.rs b/palette/src/hwb.rs
index c04816c99..d8f375a88 100644
--- a/palette/src/hwb.rs
+++ b/palette/src/hwb.rs
@@ -3,7 +3,7 @@ use float::Float;
 
 use core::any::TypeId;
 use core::marker::PhantomData;
-use core::ops::{Add, Sub};
+use core::ops::{Add, AddAssign, Sub, SubAssign};
 
 use encoding::pixel::RawPixel;
 use encoding::Srgb;
@@ -363,7 +363,7 @@ where
 {
     type Output = Hwb<S, T>;
 
-    fn add(self, other: Hwb<S, T>) -> Hwb<S, T> {
+    fn add(self, other: Hwb<S, T>) -> Self::Output {
         Hwb {
             hue: self.hue + other.hue,
             whiteness: self.whiteness + other.whiteness,
@@ -380,7 +380,7 @@ where
 {
     type Output = Hwb<S, T>;
 
-    fn add(self, c: T) -> Hwb<S, T> {
+    fn add(self, c: T) -> Self::Output {
         Hwb {
             hue: self.hue + c,
             whiteness: self.whiteness + c,
@@ -390,6 +390,30 @@ where
     }
 }
 
+impl<S, T> AddAssign<Hwb<S, T>> for Hwb<S, T>
+    where
+        T: Component + Float + AddAssign,
+        S: RgbSpace,
+{
+    fn add_assign(&mut self, other: Hwb<S, T>) {
+        self.hue += other.hue;
+        self.whiteness += other.whiteness;
+        self.blackness += other.blackness;
+    }
+}
+
+impl<S, T> AddAssign<T> for Hwb<S, T>
+    where
+        T: Component + Float + AddAssign,
+        S: RgbSpace,
+{
+    fn add_assign(&mut self, c: T) {
+        self.hue += c;
+        self.whiteness += c;
+        self.blackness += c;
+    }
+}
+
 impl<S, T> Sub<Hwb<S, T>> for Hwb<S, T>
 where
     T: Component + Float,
@@ -397,7 +421,7 @@ where
 {
     type Output = Hwb<S, T>;
 
-    fn sub(self, other: Hwb<S, T>) -> Hwb<S, T> {
+    fn sub(self, other: Hwb<S, T>) -> Self::Output {
         Hwb {
             hue: self.hue - other.hue,
             whiteness: self.whiteness - other.whiteness,
@@ -414,7 +438,7 @@ where
 {
     type Output = Hwb<S, T>;
 
-    fn sub(self, c: T) -> Hwb<S, T> {
+    fn sub(self, c: T) -> Self::Output {
         Hwb {
             hue: self.hue - c,
             whiteness: self.whiteness - c,
@@ -424,6 +448,31 @@ where
     }
 }
 
+
+impl<S, T> SubAssign<Hwb<S, T>> for Hwb<S, T>
+    where
+        T: Component + Float + SubAssign,
+        S: RgbSpace,
+{
+    fn sub_assign(&mut self, other: Hwb<S, T>) {
+        self.hue -= other.hue;
+        self.whiteness -= other.whiteness;
+        self.blackness -= other.blackness;
+    }
+}
+
+impl<S, T> SubAssign<T> for Hwb<S, T>
+    where
+        T: Component + Float + SubAssign,
+        S: RgbSpace,
+{
+    fn sub_assign(&mut self, c: T) {
+        self.hue -= c;
+        self.whiteness -= c;
+        self.blackness -= c;
+    }
+}
+
 impl<S, T, P> AsRef<P> for Hwb<S, T>
 where
     T: Component + Float,
diff --git a/palette/src/lab.rs b/palette/src/lab.rs
index 65ec364f6..8ae7af8d3 100644
--- a/palette/src/lab.rs
+++ b/palette/src/lab.rs
@@ -1,7 +1,7 @@
 use float::Float;
 
 use core::marker::PhantomData;
-use core::ops::{Add, Div, Mul, Sub};
+use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
 
 use encoding::pixel::RawPixel;
 use white_point::{D65, WhitePoint};
@@ -352,7 +352,7 @@ where
 {
     type Output = Lab<Wp, T>;
 
-    fn add(self, other: Lab<Wp, T>) -> Lab<Wp, T> {
+    fn add(self, other: Lab<Wp, T>) -> Self::Output {
         Lab {
             l: self.l + other.l,
             a: self.a + other.a,
@@ -369,7 +369,7 @@ where
 {
     type Output = Lab<Wp, T>;
 
-    fn add(self, c: T) -> Lab<Wp, T> {
+    fn add(self, c: T) -> Self::Output {
         Lab {
             l: self.l + c,
             a: self.a + c,
@@ -379,6 +379,30 @@ where
     }
 }
 
+impl<Wp, T> AddAssign<Lab<Wp, T>> for Lab<Wp, T>
+    where
+        T: Component + Float + AddAssign,
+        Wp: WhitePoint,
+{
+    fn add_assign(&mut self, other: Lab<Wp, T>) {
+        self.l += other.l;
+        self.a += other.a;
+        self.b += other.b;
+    }
+}
+
+impl<Wp, T> AddAssign<T> for Lab<Wp, T>
+    where
+        T: Component + Float + AddAssign,
+        Wp: WhitePoint,
+{
+    fn add_assign(&mut self, c: T) {
+        self.l += c;
+        self.a += c;
+        self.b += c;
+    }
+}
+
 impl<Wp, T> Sub<Lab<Wp, T>> for Lab<Wp, T>
 where
     T: Component + Float,
@@ -386,7 +410,7 @@ where
 {
     type Output = Lab<Wp, T>;
 
-    fn sub(self, other: Lab<Wp, T>) -> Lab<Wp, T> {
+    fn sub(self, other: Lab<Wp, T>) -> Self::Output {
         Lab {
             l: self.l - other.l,
             a: self.a - other.a,
@@ -403,7 +427,7 @@ where
 {
     type Output = Lab<Wp, T>;
 
-    fn sub(self, c: T) -> Lab<Wp, T> {
+    fn sub(self, c: T) -> Self::Output {
         Lab {
             l: self.l - c,
             a: self.a - c,
@@ -413,6 +437,30 @@ where
     }
 }
 
+impl<Wp, T> SubAssign<Lab<Wp, T>> for Lab<Wp, T>
+    where
+        T: Component + Float + SubAssign,
+        Wp: WhitePoint,
+{
+    fn sub_assign(&mut self, other: Lab<Wp, T>) {
+         self.l -= other.l;
+         self.a -= other.a;
+         self.b -= other.b;
+    }
+}
+
+impl<Wp, T> SubAssign<T> for Lab<Wp, T>
+    where
+        T: Component + Float + SubAssign,
+        Wp: WhitePoint,
+{
+    fn sub_assign(&mut self, c: T) {
+        self.l -= c;
+        self.a -= c;
+        self.b -= c;
+    }
+}
+
 impl<Wp, T> Mul<Lab<Wp, T>> for Lab<Wp, T>
 where
     T: Component + Float,
@@ -420,7 +468,7 @@ where
 {
     type Output = Lab<Wp, T>;
 
-    fn mul(self, other: Lab<Wp, T>) -> Lab<Wp, T> {
+    fn mul(self, other: Lab<Wp, T>) -> Self::Output {
         Lab {
             l: self.l * other.l,
             a: self.a * other.a,
@@ -437,7 +485,7 @@ where
 {
     type Output = Lab<Wp, T>;
 
-    fn mul(self, c: T) -> Lab<Wp, T> {
+    fn mul(self, c: T) -> Self::Output {
         Lab {
             l: self.l * c,
             a: self.a * c,
@@ -447,6 +495,30 @@ where
     }
 }
 
+impl<Wp, T> MulAssign<Lab<Wp, T>> for Lab<Wp, T>
+    where
+        T: Component + Float + MulAssign,
+        Wp: WhitePoint,
+{
+    fn mul_assign(&mut self, other: Lab<Wp, T>) {
+        self.l *= other.l;
+        self.a *= other.a;
+        self.b *= other.b;
+    }
+}
+
+impl<Wp, T> MulAssign<T> for Lab<Wp, T>
+    where
+        T: Component + Float + MulAssign,
+        Wp: WhitePoint,
+{
+    fn mul_assign(&mut self, c: T) {
+        self.l *= c;
+        self.a *= c;
+        self.b *= c;
+    }
+}
+
 impl<Wp, T> Div<Lab<Wp, T>> for Lab<Wp, T>
 where
     T: Component + Float,
@@ -454,7 +526,7 @@ where
 {
     type Output = Lab<Wp, T>;
 
-    fn div(self, other: Lab<Wp, T>) -> Lab<Wp, T> {
+    fn div(self, other: Lab<Wp, T>) -> Self::Output {
         Lab {
             l: self.l / other.l,
             a: self.a / other.a,
@@ -471,7 +543,7 @@ where
 {
     type Output = Lab<Wp, T>;
 
-    fn div(self, c: T) -> Lab<Wp, T> {
+    fn div(self, c: T) -> Self::Output {
         Lab {
             l: self.l / c,
             a: self.a / c,
@@ -481,6 +553,30 @@ where
     }
 }
 
+impl<Wp, T> DivAssign<Lab<Wp, T>> for Lab<Wp, T>
+    where
+        T: Component + Float + DivAssign,
+        Wp: WhitePoint,
+{
+    fn div_assign(&mut self, other: Lab<Wp, T>) {
+        self.l /= other.l;
+        self.a /= other.a;
+        self.b /= other.b;
+    }
+}
+
+impl<Wp, T> DivAssign<T> for Lab<Wp, T>
+    where
+        T: Component + Float + DivAssign,
+        Wp: WhitePoint,
+{
+    fn div_assign(&mut self, c: T) {
+        self.l /= c;
+        self.a /= c;
+        self.b /= c;
+    }
+}
+
 impl<Wp, T, P> AsRef<P> for Lab<Wp, T>
 where
     T: Component + Float,
diff --git a/palette/src/lch.rs b/palette/src/lch.rs
index c9386ecf0..13b06bf67 100644
--- a/palette/src/lch.rs
+++ b/palette/src/lch.rs
@@ -1,7 +1,7 @@
 use float::Float;
 
 use core::marker::PhantomData;
-use core::ops::{Add, Sub};
+use core::ops::{Add, AddAssign, Sub, SubAssign};
 
 use encoding::pixel::RawPixel;
 use white_point::{D65, WhitePoint};
@@ -337,7 +337,7 @@ where
 {
     type Output = Lch<Wp, T>;
 
-    fn add(self, other: Lch<Wp, T>) -> Lch<Wp, T> {
+    fn add(self, other: Lch<Wp, T>) -> Self::Output {
         Lch {
             l: self.l + other.l,
             chroma: self.chroma + other.chroma,
@@ -354,7 +354,7 @@ where
 {
     type Output = Lch<Wp, T>;
 
-    fn add(self, c: T) -> Lch<Wp, T> {
+    fn add(self, c: T) -> Self::Output {
         Lch {
             l: self.l + c,
             chroma: self.chroma + c,
@@ -364,6 +364,30 @@ where
     }
 }
 
+impl<Wp, T> AddAssign<Lch<Wp, T>> for Lch<Wp, T>
+where
+    T: Component + Float + AddAssign,
+    Wp: WhitePoint,
+{
+    fn add_assign(&mut self, other: Lch<Wp, T>) {
+        self.l += other.l;
+        self.chroma += other.chroma;
+        self.hue += other.hue;
+    }
+}
+
+impl<Wp, T> AddAssign<T> for Lch<Wp, T>
+    where
+        T: Component + Float + AddAssign,
+        Wp: WhitePoint,
+{
+    fn add_assign(&mut self, c: T) {
+        self.l += c;
+        self.chroma += c;
+        self.hue += c;
+    }
+}
+
 impl<Wp, T> Sub<Lch<Wp, T>> for Lch<Wp, T>
 where
     T: Component + Float,
@@ -371,7 +395,7 @@ where
 {
     type Output = Lch<Wp, T>;
 
-    fn sub(self, other: Lch<Wp, T>) -> Lch<Wp, T> {
+    fn sub(self, other: Lch<Wp, T>) -> Self::Output {
         Lch {
             l: self.l - other.l,
             chroma: self.chroma - other.chroma,
@@ -388,7 +412,7 @@ where
 {
     type Output = Lch<Wp, T>;
 
-    fn sub(self, c: T) -> Lch<Wp, T> {
+    fn sub(self, c: T) -> Self::Output {
         Lch {
             l: self.l - c,
             chroma: self.chroma - c,
@@ -398,6 +422,30 @@ where
     }
 }
 
+impl<Wp, T> SubAssign<Lch<Wp, T>> for Lch<Wp, T>
+where
+    T: Component + Float + SubAssign,
+    Wp: WhitePoint,
+{
+    fn sub_assign(&mut self, other: Lch<Wp, T>) {
+        self.l -= other.l;
+        self.chroma -= other.chroma;
+        self.hue -= other.hue;
+    }
+}
+
+impl<Wp, T> SubAssign<T> for Lch<Wp, T>
+where
+    T: Component + Float + SubAssign,
+    Wp: WhitePoint,
+{
+    fn sub_assign(&mut self, c: T) {
+        self.l -= c;
+        self.chroma -= c;
+        self.hue -= c;
+    }
+}
+
 impl<Wp, T, P> AsRef<P> for Lch<Wp, T>
 where
     T: Component + Float,
diff --git a/palette/src/luma/luma.rs b/palette/src/luma/luma.rs
index bb5824ee3..b8e9bae12 100644
--- a/palette/src/luma/luma.rs
+++ b/palette/src/luma/luma.rs
@@ -1,6 +1,6 @@
 use core::fmt;
 use core::marker::PhantomData;
-use core::ops::{Add, Div, Mul, Sub};
+use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
 
 use approx::{AbsDiffEq, RelativeEq, UlpsEq};
 
@@ -412,6 +412,26 @@ where
     }
 }
 
+impl<S, T> AddAssign<Luma<S, T>> for Luma<S, T>
+where
+    T: Component + AddAssign,
+    S: LumaStandard<TransferFn = LinearFn>,
+{
+    fn add_assign(&mut self, other: Luma<S, T>) {
+        self.luma += other.luma;
+    }
+}
+
+impl<S, T> AddAssign<T> for Luma<S, T>
+where
+    T: Component + AddAssign,
+    S: LumaStandard<TransferFn = LinearFn>,
+{
+    fn add_assign(&mut self, c: T) {
+        self.luma += c;
+    }
+}
+
 impl<S, T> Sub<Luma<S, T>> for Luma<S, T>
 where
     T: Component + Sub,
@@ -444,6 +464,26 @@ where
     }
 }
 
+impl<S, T> SubAssign<Luma<S, T>> for Luma<S, T>
+where
+    T: Component + SubAssign,
+    S: LumaStandard<TransferFn = LinearFn>,
+{
+    fn sub_assign(&mut self, other: Luma<S, T>) {
+        self.luma -= other.luma;
+    }
+}
+
+impl<S, T> SubAssign<T> for Luma<S, T>
+where
+    T: Component + SubAssign,
+    S: LumaStandard<TransferFn = LinearFn>,
+{
+    fn sub_assign(&mut self, c: T) {
+        self.luma -= c;
+    }
+}
+
 impl<S, T> Mul<Luma<S, T>> for Luma<S, T>
 where
     T: Component + Mul,
@@ -476,6 +516,26 @@ where
     }
 }
 
+impl<S, T> MulAssign<Luma<S, T>> for Luma<S, T>
+where
+    T: Component + MulAssign,
+    S: LumaStandard<TransferFn = LinearFn>,
+{
+    fn mul_assign(&mut self, other: Luma<S, T>) {
+        self.luma *= other.luma;
+    }
+}
+
+impl<S, T> MulAssign<T> for Luma<S, T>
+where
+    T: Component + MulAssign,
+    S: LumaStandard<TransferFn = LinearFn>,
+{
+    fn mul_assign(&mut self, c: T) {
+        self.luma *= c;
+    }
+}
+
 impl<S, T> Div<Luma<S, T>> for Luma<S, T>
 where
     T: Component + Div,
@@ -508,6 +568,26 @@ where
     }
 }
 
+impl<S, T> DivAssign<Luma<S, T>> for Luma<S, T>
+where
+    T: Component + DivAssign,
+    S: LumaStandard<TransferFn = LinearFn>,
+{
+    fn div_assign(&mut self, other: Luma<S, T>) {
+        self.luma /= other.luma;
+    }
+}
+
+impl<S, T> DivAssign<T> for Luma<S, T>
+where
+    T: Component + DivAssign,
+    S: LumaStandard<TransferFn = LinearFn>,
+{
+    fn div_assign(&mut self, c: T) {
+        self.luma /= c;
+    }
+}
+
 impl<S, T, P> AsRef<P> for Luma<S, T>
 where
     T: Component,
diff --git a/palette/src/rgb/rgb.rs b/palette/src/rgb/rgb.rs
index 35ca9eb3a..c5b71fcef 100644
--- a/palette/src/rgb/rgb.rs
+++ b/palette/src/rgb/rgb.rs
@@ -1,7 +1,7 @@
 use core::any::TypeId;
 use core::fmt;
 use core::marker::PhantomData;
-use core::ops::{Add, Div, Mul, Sub};
+use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
 
 use approx::{AbsDiffEq, RelativeEq, UlpsEq};
 use float::Float;
@@ -420,6 +420,30 @@ where
     }
 }
 
+impl<S, T> AddAssign<Rgb<S, T>> for Rgb<S, T>
+where
+    S: RgbStandard<TransferFn = LinearFn>,
+    T: Component + AddAssign,
+{
+    fn add_assign(&mut self, other: Rgb<S, T>) {
+        self.red += other.red;
+        self.green += other.green;
+        self.blue += other.blue;
+    }
+}
+
+impl<S, T> AddAssign<T> for Rgb<S, T>
+where
+    S: RgbStandard<TransferFn = LinearFn>,
+    T: Component + AddAssign,
+{
+    fn add_assign(&mut self, c: T) {
+        self.red += c;
+        self.green += c;
+        self.blue += c;
+    }
+}
+
 impl<S, T> Sub<Rgb<S, T>> for Rgb<S, T>
 where
     S: RgbStandard<TransferFn = LinearFn>,
@@ -456,6 +480,30 @@ where
     }
 }
 
+impl<S, T> SubAssign<Rgb<S, T>> for Rgb<S, T>
+where
+    S: RgbStandard<TransferFn = LinearFn>,
+    T: Component + SubAssign,
+{
+    fn sub_assign(&mut self, other: Rgb<S, T>) {
+        self.red -= other.red;
+        self.green -= other.green;
+        self.blue -= other.blue;
+    }
+}
+
+impl<S, T> SubAssign<T> for Rgb<S, T>
+where
+    S: RgbStandard<TransferFn = LinearFn>,
+    T: Component + SubAssign,
+{
+    fn sub_assign(&mut self, c: T) {
+        self.red -= c;
+        self.green -= c;
+        self.blue -= c;
+    }
+}
+
 impl<S, T> Mul<Rgb<S, T>> for Rgb<S, T>
 where
     S: RgbStandard<TransferFn = LinearFn>,
@@ -492,6 +540,30 @@ where
     }
 }
 
+impl<S, T> MulAssign<Rgb<S, T>> for Rgb<S, T>
+where
+    S: RgbStandard<TransferFn = LinearFn>,
+    T: Component + MulAssign,
+{
+    fn mul_assign(&mut self, other: Rgb<S, T>) {
+        self.red *= other.red;
+        self.green *= other.green;
+        self.blue *= other.blue;
+    }
+}
+
+impl<S, T> MulAssign<T> for Rgb<S, T>
+where
+    S: RgbStandard<TransferFn = LinearFn>,
+    T: Component + MulAssign,
+{
+    fn mul_assign(&mut self, c: T) {
+        self.red *= c;
+        self.green *= c;
+        self.blue *= c;
+    }
+}
+
 impl<S, T> Div<Rgb<S, T>> for Rgb<S, T>
 where
     S: RgbStandard<TransferFn = LinearFn>,
@@ -528,6 +600,30 @@ where
     }
 }
 
+impl<S, T> DivAssign<Rgb<S, T>> for Rgb<S, T>
+where
+    S: RgbStandard<TransferFn = LinearFn>,
+    T: Component + DivAssign,
+{
+    fn div_assign(&mut self, other: Rgb<S, T>) {
+        self.red /= other.red;
+        self.green /= other.green;
+        self.blue /= other.blue;
+    }
+}
+
+impl<S, T> DivAssign<T> for Rgb<S, T>
+where
+    S: RgbStandard<TransferFn = LinearFn>,
+    T: Component + DivAssign,
+{
+    fn div_assign(&mut self, c: T) {
+        self.red /= c;
+        self.green /= c;
+        self.blue /= c;
+    }
+}
+
 impl<S, Wp, T> From<Xyz<Wp, T>> for Rgb<S, T>
 where
     S: RgbStandard,
diff --git a/palette/src/xyz.rs b/palette/src/xyz.rs
index 84ab59859..46da956fa 100644
--- a/palette/src/xyz.rs
+++ b/palette/src/xyz.rs
@@ -1,7 +1,7 @@
 use float::Float;
 
 use core::marker::PhantomData;
-use core::ops::{Add, Div, Mul, Sub};
+use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
 
 use encoding::pixel::RawPixel;
 use luma::LumaStandard;
@@ -359,7 +359,7 @@ where
 {
     type Output = Xyz<Wp, T>;
 
-    fn add(self, other: Xyz<Wp, T>) -> Xyz<Wp, T> {
+    fn add(self, other: Xyz<Wp, T>) -> Self::Output {
         Xyz {
             x: self.x + other.x,
             y: self.y + other.y,
@@ -376,7 +376,7 @@ where
 {
     type Output = Xyz<Wp, T>;
 
-    fn add(self, c: T) -> Xyz<Wp, T> {
+    fn add(self, c: T) -> Self::Output {
         Xyz {
             x: self.x + c,
             y: self.y + c,
@@ -386,6 +386,30 @@ where
     }
 }
 
+impl<Wp, T> AddAssign<Xyz<Wp, T>> for Xyz<Wp, T>
+where
+    T: Component + Float + AddAssign,
+    Wp: WhitePoint,
+{
+    fn add_assign(&mut self, other: Xyz<Wp, T>) {
+        self.x += other.x;
+        self.y += other.y;
+        self.z += other.z;
+    }
+}
+
+impl<Wp, T> AddAssign<T> for Xyz<Wp, T>
+where
+    T: Component + Float + AddAssign,
+    Wp: WhitePoint,
+{
+    fn add_assign(&mut self, c: T) {
+        self.x += c;
+        self.y += c;
+        self.z += c;
+    }
+}
+
 impl<Wp, T> Sub<Xyz<Wp, T>> for Xyz<Wp, T>
 where
     T: Component + Float,
@@ -393,7 +417,7 @@ where
 {
     type Output = Xyz<Wp, T>;
 
-    fn sub(self, other: Xyz<Wp, T>) -> Xyz<Wp, T> {
+    fn sub(self, other: Xyz<Wp, T>) -> Self::Output {
         Xyz {
             x: self.x - other.x,
             y: self.y - other.y,
@@ -410,7 +434,7 @@ where
 {
     type Output = Xyz<Wp, T>;
 
-    fn sub(self, c: T) -> Xyz<Wp, T> {
+    fn sub(self, c: T) -> Self::Output {
         Xyz {
             x: self.x - c,
             y: self.y - c,
@@ -420,6 +444,30 @@ where
     }
 }
 
+impl<Wp, T> SubAssign<Xyz<Wp, T>> for Xyz<Wp, T>
+where
+    T: Component + Float + SubAssign,
+    Wp: WhitePoint,
+{
+    fn sub_assign(&mut self, other: Xyz<Wp, T>) {
+        self.x -= other.x;
+        self.y -= other.y;
+        self.z -= other.z;
+    }
+}
+
+impl<Wp, T> SubAssign<T> for Xyz<Wp, T>
+where
+    T: Component + Float + SubAssign,
+    Wp: WhitePoint,
+{
+    fn sub_assign(&mut self, c: T) {
+        self.x -= c;
+        self.y -= c;
+        self.z -= c;
+    }
+}
+
 impl<Wp, T> Mul<Xyz<Wp, T>> for Xyz<Wp, T>
 where
     T: Component + Float,
@@ -427,7 +475,7 @@ where
 {
     type Output = Xyz<Wp, T>;
 
-    fn mul(self, other: Xyz<Wp, T>) -> Xyz<Wp, T> {
+    fn mul(self, other: Xyz<Wp, T>) -> Self::Output {
         Xyz {
             x: self.x * other.x,
             y: self.y * other.y,
@@ -444,7 +492,7 @@ where
 {
     type Output = Xyz<Wp, T>;
 
-    fn mul(self, c: T) -> Xyz<Wp, T> {
+    fn mul(self, c: T) -> Self::Output {
         Xyz {
             x: self.x * c,
             y: self.y * c,
@@ -454,6 +502,30 @@ where
     }
 }
 
+impl<Wp, T> MulAssign<Xyz<Wp, T>> for Xyz<Wp, T>
+where
+    T: Component + Float + MulAssign,
+    Wp: WhitePoint,
+{
+    fn mul_assign(&mut self, other: Xyz<Wp, T>) {
+        self.x *= other.x;
+        self.y *= other.y;
+        self.z *= other.z;
+    }
+}
+
+impl<Wp, T> MulAssign<T> for Xyz<Wp, T>
+where
+    T: Component + Float + MulAssign,
+    Wp: WhitePoint,
+{
+    fn mul_assign(&mut self, c: T) {
+        self.x *= c;
+        self.y *= c;
+        self.z *= c;
+    }
+}
+
 impl<Wp, T> Div<Xyz<Wp, T>> for Xyz<Wp, T>
 where
     T: Component + Float,
@@ -461,7 +533,7 @@ where
 {
     type Output = Xyz<Wp, T>;
 
-    fn div(self, other: Xyz<Wp, T>) -> Xyz<Wp, T> {
+    fn div(self, other: Xyz<Wp, T>) -> Self::Output {
         Xyz {
             x: self.x / other.x,
             y: self.y / other.y,
@@ -478,7 +550,7 @@ where
 {
     type Output = Xyz<Wp, T>;
 
-    fn div(self, c: T) -> Xyz<Wp, T> {
+    fn div(self, c: T) -> Self::Output {
         Xyz {
             x: self.x / c,
             y: self.y / c,
@@ -488,6 +560,30 @@ where
     }
 }
 
+impl<Wp, T> DivAssign<Xyz<Wp, T>> for Xyz<Wp, T>
+where
+    T: Component + Float + DivAssign,
+    Wp: WhitePoint,
+{
+    fn div_assign(&mut self, other: Xyz<Wp, T>) {
+        self.x /= other.x;
+        self.y /= other.y;
+        self.z /= other.z;
+    }
+}
+
+impl<Wp, T> DivAssign<T> for Xyz<Wp, T>
+where
+    T: Component + Float + DivAssign,
+    Wp: WhitePoint,
+{
+    fn div_assign(&mut self, c: T) {
+        self.x /= c;
+        self.y /= c;
+        self.z /= c;
+    }
+}
+
 impl<Wp, T, P> AsRef<P> for Xyz<Wp, T>
 where
     T: Component + Float,
diff --git a/palette/src/yxy.rs b/palette/src/yxy.rs
index 01f51feee..005920e90 100644
--- a/palette/src/yxy.rs
+++ b/palette/src/yxy.rs
@@ -1,7 +1,7 @@
 use float::Float;
 
 use core::marker::PhantomData;
-use core::ops::{Add, Div, Mul, Sub};
+use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
 
 use clamp;
 use encoding::pixel::RawPixel;
@@ -325,7 +325,7 @@ where
 {
     type Output = Yxy<Wp, T>;
 
-    fn add(self, other: Yxy<Wp, T>) -> Yxy<Wp, T> {
+    fn add(self, other: Yxy<Wp, T>) -> Self::Output {
         Yxy {
             x: self.x + other.x,
             y: self.y + other.y,
@@ -342,7 +342,7 @@ where
 {
     type Output = Yxy<Wp, T>;
 
-    fn add(self, c: T) -> Yxy<Wp, T> {
+    fn add(self, c: T) -> Self::Output {
         Yxy {
             x: self.x + c,
             y: self.y + c,
@@ -352,6 +352,30 @@ where
     }
 }
 
+impl<Wp, T> AddAssign<Yxy<Wp, T>> for Yxy<Wp, T>
+where
+    T: Component + Float + AddAssign,
+    Wp: WhitePoint,
+{
+    fn add_assign(&mut self, other: Yxy<Wp, T>) {
+        self.x += other.x;
+        self.y += other.y;
+        self.luma += other.luma;
+    }
+}
+
+impl<Wp, T> AddAssign<T> for Yxy<Wp, T>
+where
+    T: Component + Float + AddAssign,
+    Wp: WhitePoint,
+{
+    fn add_assign(&mut self, c: T) {
+        self.x += c;
+        self.y += c;
+        self.luma += c;
+    }
+}
+
 impl<Wp, T> Sub<Yxy<Wp, T>> for Yxy<Wp, T>
 where
     T: Component + Float,
@@ -359,7 +383,7 @@ where
 {
     type Output = Yxy<Wp, T>;
 
-    fn sub(self, other: Yxy<Wp, T>) -> Yxy<Wp, T> {
+    fn sub(self, other: Yxy<Wp, T>) -> Self::Output {
         Yxy {
             x: self.x - other.x,
             y: self.y - other.y,
@@ -376,7 +400,7 @@ where
 {
     type Output = Yxy<Wp, T>;
 
-    fn sub(self, c: T) -> Yxy<Wp, T> {
+    fn sub(self, c: T) -> Self::Output {
         Yxy {
             x: self.x - c,
             y: self.y - c,
@@ -386,6 +410,30 @@ where
     }
 }
 
+impl<Wp, T> SubAssign<Yxy<Wp, T>> for Yxy<Wp, T>
+    where
+        T: Component + Float + SubAssign,
+        Wp: WhitePoint,
+{
+    fn sub_assign(&mut self, other: Yxy<Wp, T>) {
+        self.x -= other.x;
+        self.y -= other.y;
+        self.luma -= other.luma;
+    }
+}
+
+impl<Wp, T> SubAssign<T> for Yxy<Wp, T>
+    where
+        T: Component + Float + SubAssign,
+        Wp: WhitePoint,
+{
+    fn sub_assign(&mut self, c: T) {
+        self.x -= c;
+        self.y -= c;
+        self.luma -= c;
+    }
+}
+
 impl<Wp, T> Mul<Yxy<Wp, T>> for Yxy<Wp, T>
 where
     T: Component + Float,
@@ -393,7 +441,7 @@ where
 {
     type Output = Yxy<Wp, T>;
 
-    fn mul(self, other: Yxy<Wp, T>) -> Yxy<Wp, T> {
+    fn mul(self, other: Yxy<Wp, T>) -> Self::Output {
         Yxy {
             x: self.x * other.x,
             y: self.y * other.y,
@@ -410,7 +458,7 @@ where
 {
     type Output = Yxy<Wp, T>;
 
-    fn mul(self, c: T) -> Yxy<Wp, T> {
+    fn mul(self, c: T) -> Self::Output {
         Yxy {
             x: self.x * c,
             y: self.y * c,
@@ -420,6 +468,30 @@ where
     }
 }
 
+impl<Wp, T> MulAssign<Yxy<Wp, T>> for Yxy<Wp, T>
+    where
+        T: Component + Float + MulAssign,
+        Wp: WhitePoint,
+{
+    fn mul_assign(&mut self, other: Yxy<Wp, T>) {
+        self.x *= other.x;
+        self.y *= other.y;
+        self.luma *= other.luma;
+    }
+}
+
+impl<Wp, T> MulAssign<T> for Yxy<Wp, T>
+    where
+        T: Component + Float + MulAssign,
+        Wp: WhitePoint,
+{
+    fn mul_assign(&mut self, c: T) {
+        self.x *= c;
+        self.y *= c;
+        self.luma *= c;
+    }
+}
+
 impl<Wp, T> Div<Yxy<Wp, T>> for Yxy<Wp, T>
 where
     T: Component + Float,
@@ -427,7 +499,7 @@ where
 {
     type Output = Yxy<Wp, T>;
 
-    fn div(self, other: Yxy<Wp, T>) -> Yxy<Wp, T> {
+    fn div(self, other: Yxy<Wp, T>) -> Self::Output {
         Yxy {
             x: self.x / other.x,
             y: self.y / other.y,
@@ -444,7 +516,7 @@ where
 {
     type Output = Yxy<Wp, T>;
 
-    fn div(self, c: T) -> Yxy<Wp, T> {
+    fn div(self, c: T) -> Self::Output {
         Yxy {
             x: self.x / c,
             y: self.y / c,
@@ -454,6 +526,30 @@ where
     }
 }
 
+impl<Wp, T> DivAssign<Yxy<Wp, T>> for Yxy<Wp, T>
+    where
+        T: Component + Float + DivAssign,
+        Wp: WhitePoint,
+{
+    fn div_assign(&mut self, other: Yxy<Wp, T>) {
+        self.x /= other.x;
+        self.y /= other.y;
+        self.luma /= other.luma;
+    }
+}
+
+impl<Wp, T> DivAssign<T> for Yxy<Wp, T>
+    where
+        T: Component + Float + DivAssign,
+        Wp: WhitePoint,
+{
+    fn div_assign(&mut self, c: T) {
+        self.x /= c;
+        self.y /= c;
+        self.luma /= c;
+    }
+}
+
 impl<Wp, T, P> AsRef<P> for Yxy<Wp, T>
 where
     T: Component + Float,