diff --git a/doc/source/fmpcb.rst b/doc/source/fmpcb.rst
index 914471e9..cbc3f8ec 100644
--- a/doc/source/fmpcb.rst
+++ b/doc/source/fmpcb.rst
@@ -247,6 +247,8 @@ Arithmetic
 
 .. function:: void fmpcb_mul_ui(fmpcb_t z, const fmpcb_t x, ulong y, long prec)
 
+.. function:: void fmpcb_mul_si(fmpcb_t z, const fmpcb_t x, long y, long prec)
+
 .. function:: void fmpcb_mul_fmpz(fmpcb_t z, const fmpcb_t x, const fmpz_t y, long prec)
 
 .. function:: void fmpcb_mul_fmprb(fmpcb_t z, const fmpcb_t x, const fmprb_t y, long prec)
@@ -281,6 +283,8 @@ Arithmetic
 
 .. function:: void fmpcb_addmul_ui(fmpcb_t z, const fmpcb_t x, ulong y, long prec)
 
+.. function:: void fmpcb_addmul_si(fmpcb_t z, const fmpcb_t x, long y, long prec)
+
 .. function:: void fmpcb_addmul_fmpz(fmpcb_t z, const fmpcb_t x, const fmpz_t y, long prec)
 
 .. function:: void fmpcb_addmul_fmprb(fmpcb_t z, const fmpcb_t x, const fmprb_t y, long prec)
@@ -291,6 +295,8 @@ Arithmetic
 
 .. function:: void fmpcb_submul_ui(fmpcb_t z, const fmpcb_t x, ulong y, long prec)
 
+.. function:: void fmpcb_submul_si(fmpcb_t z, const fmpcb_t x, long y, long prec)
+
 .. function:: void fmpcb_submul_fmpz(fmpcb_t z, const fmpcb_t x, const fmpz_t y, long prec)
 
 .. function:: void fmpcb_submul_fmprb(fmpcb_t z, const fmpcb_t x, const fmprb_t y, long prec)
diff --git a/doc/source/fmpcb_mat.rst b/doc/source/fmpcb_mat.rst
index ecf35aa8..706c6ecd 100644
--- a/doc/source/fmpcb_mat.rst
+++ b/doc/source/fmpcb_mat.rst
@@ -135,6 +135,45 @@ Arithmetic
     Sets *res* to *mat* raised to the power *exp*. Requires that *mat*
     is a square matrix.
 
+
+Scalar arithmetic
+-------------------------------------------------------------------------------
+
+.. function:: void fmpcb_mat_scalar_mul_2exp_si(fmpcb_mat_t B, const fmpcb_mat_t A, long c)
+
+    Sets *B* to *A* multiplied by `2^c`.
+
+.. function:: void fmpcb_mat_scalar_addmul_si(fmpcb_mat_t B, const fmpcb_mat_t A, long c, long prec)
+
+.. function:: void fmpcb_mat_scalar_addmul_fmpz(fmpcb_mat_t B, const fmpcb_mat_t A, const fmpz_t c, long prec)
+
+.. function:: void fmpcb_mat_scalar_addmul_fmprb(fmpcb_mat_t B, const fmpcb_mat_t A, const fmprb_t c, long prec)
+
+.. function:: void fmpcb_mat_scalar_addmul_fmpcb(fmpcb_mat_t B, const fmpcb_mat_t A, const fmpcb_t c, long prec)
+
+    Sets *B* to `B + A \times c`.
+
+.. function:: void fmpcb_mat_scalar_mul_si(fmpcb_mat_t B, const fmpcb_mat_t A, long c, long prec)
+
+.. function:: void fmpcb_mat_scalar_mul_fmpz(fmpcb_mat_t B, const fmpcb_mat_t A, const fmpz_t c, long prec)
+
+.. function:: void fmpcb_mat_scalar_mul_fmprb(fmpcb_mat_t B, const fmpcb_mat_t A, const fmprb_t c, long prec)
+
+.. function:: void fmpcb_mat_scalar_mul_fmpcb(fmpcb_mat_t B, const fmpcb_mat_t A, const fmpcb_t c, long prec)
+
+    Sets *B* to `A \times c`.
+
+.. function:: void fmpcb_mat_scalar_div_si(fmpcb_mat_t B, const fmpcb_mat_t A, long c, long prec)
+
+.. function:: void fmpcb_mat_scalar_div_fmpz(fmpcb_mat_t B, const fmpcb_mat_t A, const fmpz_t c, long prec)
+
+.. function:: void fmpcb_mat_scalar_div_fmprb(fmpcb_mat_t B, const fmpcb_mat_t A, const fmprb_t c, long prec)
+
+.. function:: void fmpcb_mat_scalar_div_fmpcb(fmpcb_mat_t B, const fmpcb_mat_t A, const fmpcb_t c, long prec)
+
+    Sets *B* to `A / c`.
+
+
 Gaussian elimination and solving
 -------------------------------------------------------------------------------
 
diff --git a/doc/source/fmprb_mat.rst b/doc/source/fmprb_mat.rst
index 0a444eca..a503b16c 100644
--- a/doc/source/fmprb_mat.rst
+++ b/doc/source/fmprb_mat.rst
@@ -135,6 +135,39 @@ Arithmetic
     Sets *res* to *mat* raised to the power *exp*. Requires that *mat*
     is a square matrix.
 
+
+Scalar arithmetic
+-------------------------------------------------------------------------------
+
+.. function:: void fmprb_mat_scalar_mul_2exp_si(fmprb_mat_t B, const fmprb_mat_t A, long c)
+
+    Sets *B* to *A* multiplied by `2^c`.
+
+.. function:: void fmprb_mat_scalar_addmul_si(fmprb_mat_t B, const fmprb_mat_t A, long c, long prec)
+
+.. function:: void fmprb_mat_scalar_addmul_fmpz(fmprb_mat_t B, const fmprb_mat_t A, const fmpz_t c, long prec)
+
+.. function:: void fmprb_mat_scalar_addmul_fmprb(fmprb_mat_t B, const fmprb_mat_t A, const fmprb_t c, long prec)
+
+    Sets *B* to `B + A \times c`.
+
+.. function:: void fmprb_mat_scalar_mul_si(fmprb_mat_t B, const fmprb_mat_t A, long c, long prec)
+
+.. function:: void fmprb_mat_scalar_mul_fmpz(fmprb_mat_t B, const fmprb_mat_t A, const fmpz_t c, long prec)
+
+.. function:: void fmprb_mat_scalar_mul_fmprb(fmprb_mat_t B, const fmprb_mat_t A, const fmprb_t c, long prec)
+
+    Sets *B* to `A \times c`.
+
+.. function:: void fmprb_mat_scalar_div_si(fmprb_mat_t B, const fmprb_mat_t A, long c, long prec)
+
+.. function:: void fmprb_mat_scalar_div_fmpz(fmprb_mat_t B, const fmprb_mat_t A, const fmpz_t c, long prec)
+
+.. function:: void fmprb_mat_scalar_div_fmprb(fmprb_mat_t B, const fmprb_mat_t A, const fmprb_t c, long prec)
+
+    Sets *B* to `A / c`.
+
+
 Gaussian elimination and solving
 -------------------------------------------------------------------------------
 
diff --git a/fmpcb.h b/fmpcb.h
index aa79015f..98d35b72 100644
--- a/fmpcb.h
+++ b/fmpcb.h
@@ -401,6 +401,13 @@ fmpcb_mul_ui(fmpcb_t z, const fmpcb_t x, ulong y, long prec)
     fmprb_mul_ui(fmpcb_imagref(z), fmpcb_imagref(x), y, prec);
 }
 
+static __inline__ void
+fmpcb_mul_si(fmpcb_t z, const fmpcb_t x, long y, long prec)
+{
+    fmprb_mul_si(fmpcb_realref(z), fmpcb_realref(x), y, prec);
+    fmprb_mul_si(fmpcb_imagref(z), fmpcb_imagref(x), y, prec);
+}
+
 static __inline__ void
 fmpcb_mul_fmpz(fmpcb_t z, const fmpcb_t x, const fmpz_t y, long prec)
 {
@@ -468,6 +475,13 @@ fmpcb_addmul_ui(fmpcb_t z, const fmpcb_t x, ulong y, long prec)
     fmprb_addmul_ui(fmpcb_imagref(z), fmpcb_imagref(x), y, prec);
 }
 
+static __inline__ void
+fmpcb_addmul_si(fmpcb_t z, const fmpcb_t x, long y, long prec)
+{
+    fmprb_addmul_si(fmpcb_realref(z), fmpcb_realref(x), y, prec);
+    fmprb_addmul_si(fmpcb_imagref(z), fmpcb_imagref(x), y, prec);
+}
+
 static __inline__ void
 fmpcb_submul_ui(fmpcb_t z, const fmpcb_t x, ulong y, long prec)
 {
@@ -475,6 +489,13 @@ fmpcb_submul_ui(fmpcb_t z, const fmpcb_t x, ulong y, long prec)
     fmprb_submul_ui(fmpcb_imagref(z), fmpcb_imagref(x), y, prec);
 }
 
+static __inline__ void
+fmpcb_submul_si(fmpcb_t z, const fmpcb_t x, long y, long prec)
+{
+    fmprb_submul_si(fmpcb_realref(z), fmpcb_realref(x), y, prec);
+    fmprb_submul_si(fmpcb_imagref(z), fmpcb_imagref(x), y, prec);
+}
+
 static __inline__ void
 fmpcb_addmul_fmpz(fmpcb_t z, const fmpcb_t x, const fmpz_t y, long prec)
 {
@@ -529,6 +550,13 @@ fmpcb_div_si(fmpcb_t z, const fmpcb_t x, long c, long prec)
     fmprb_div_si(fmpcb_imagref(z), fmpcb_imagref(x), c, prec);
 }
 
+static __inline__ void
+fmpcb_div_fmprb(fmpcb_t z, const fmpcb_t x, const fmprb_t c, long prec)
+{
+    fmprb_div(fmpcb_realref(z), fmpcb_realref(x), c, prec);
+    fmprb_div(fmpcb_imagref(z), fmpcb_imagref(x), c, prec);
+}
+
 static __inline__ void
 fmpcb_div_fmpz(fmpcb_t z, const fmpcb_t x, const fmpz_t c, long prec)
 {
diff --git a/fmpcb_mat.h b/fmpcb_mat.h
index 5093f942..19f6010f 100644
--- a/fmpcb_mat.h
+++ b/fmpcb_mat.h
@@ -109,6 +109,138 @@ void fmpcb_mat_mul(fmpcb_mat_t res, const fmpcb_mat_t mat1, const fmpcb_mat_t ma
 
 void fmpcb_mat_pow_ui(fmpcb_mat_t B, const fmpcb_mat_t A, ulong exp, long prec);
 
+/* Scalar arithmetic */
+
+static __inline__ void
+fmpcb_mat_scalar_mul_2exp_si(fmpcb_mat_t B, const fmpcb_mat_t A, long c)
+{
+    long i, j;
+
+    for (i = 0; i < fmpcb_mat_nrows(A); i++)
+        for (j = 0; j < fmpcb_mat_ncols(A); j++)
+            fmpcb_mul_2exp_si(fmpcb_mat_entry(B, i, j), fmpcb_mat_entry(A, i, j), c);
+}
+
+static __inline__ void
+fmpcb_mat_scalar_addmul_si(fmpcb_mat_t B, const fmpcb_mat_t A, long c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmpcb_mat_nrows(A); i++)
+        for (j = 0; j < fmpcb_mat_ncols(A); j++)
+            fmpcb_addmul_si(fmpcb_mat_entry(B, i, j), fmpcb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmpcb_mat_scalar_mul_si(fmpcb_mat_t B, const fmpcb_mat_t A, long c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmpcb_mat_nrows(A); i++)
+        for (j = 0; j < fmpcb_mat_ncols(A); j++)
+            fmpcb_mul_si(fmpcb_mat_entry(B, i, j), fmpcb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmpcb_mat_scalar_div_si(fmpcb_mat_t B, const fmpcb_mat_t A, long c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmpcb_mat_nrows(A); i++)
+        for (j = 0; j < fmpcb_mat_ncols(A); j++)
+            fmpcb_div_si(fmpcb_mat_entry(B, i, j), fmpcb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmpcb_mat_scalar_addmul_fmpz(fmpcb_mat_t B, const fmpcb_mat_t A, const fmpz_t c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmpcb_mat_nrows(A); i++)
+        for (j = 0; j < fmpcb_mat_ncols(A); j++)
+            fmpcb_addmul_fmpz(fmpcb_mat_entry(B, i, j), fmpcb_mat_entry(A, i, j), c, prec);
+}
+
+void
+fmpcb_mat_scalar_mul_fmpz(fmpcb_mat_t B, const fmpcb_mat_t A, const fmpz_t c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmpcb_mat_nrows(A); i++)
+        for (j = 0; j < fmpcb_mat_ncols(A); j++)
+            fmpcb_mul_fmpz(fmpcb_mat_entry(B, i, j), fmpcb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmpcb_mat_scalar_div_fmpz(fmpcb_mat_t B, const fmpcb_mat_t A, const fmpz_t c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmpcb_mat_nrows(A); i++)
+        for (j = 0; j < fmpcb_mat_ncols(A); j++)
+            fmpcb_div_fmpz(fmpcb_mat_entry(B, i, j), fmpcb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmpcb_mat_scalar_addmul_fmpcb(fmpcb_mat_t B, const fmpcb_mat_t A, const fmpcb_t c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmpcb_mat_nrows(A); i++)
+        for (j = 0; j < fmpcb_mat_ncols(A); j++)
+            fmpcb_addmul(fmpcb_mat_entry(B, i, j), fmpcb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmpcb_mat_scalar_mul_fmpcb(fmpcb_mat_t B, const fmpcb_mat_t A, const fmpcb_t c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmpcb_mat_nrows(A); i++)
+        for (j = 0; j < fmpcb_mat_ncols(A); j++)
+            fmpcb_mul(fmpcb_mat_entry(B, i, j), fmpcb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmpcb_mat_scalar_div_fmpcb(fmpcb_mat_t B, const fmpcb_mat_t A, const fmpcb_t c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmpcb_mat_nrows(A); i++)
+        for (j = 0; j < fmpcb_mat_ncols(A); j++)
+            fmpcb_div(fmpcb_mat_entry(B, i, j), fmpcb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmpcb_mat_scalar_addmul_fmprb(fmpcb_mat_t B, const fmpcb_mat_t A, const fmprb_t c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmpcb_mat_nrows(A); i++)
+        for (j = 0; j < fmpcb_mat_ncols(A); j++)
+            fmpcb_addmul_fmprb(fmpcb_mat_entry(B, i, j), fmpcb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmpcb_mat_scalar_mul_fmprb(fmpcb_mat_t B, const fmpcb_mat_t A, const fmprb_t c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmpcb_mat_nrows(A); i++)
+        for (j = 0; j < fmpcb_mat_ncols(A); j++)
+            fmpcb_mul_fmprb(fmpcb_mat_entry(B, i, j), fmpcb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmpcb_mat_scalar_div_fmprb(fmpcb_mat_t B, const fmpcb_mat_t A, const fmprb_t c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmpcb_mat_nrows(A); i++)
+        for (j = 0; j < fmpcb_mat_ncols(A); j++)
+            fmpcb_div_fmprb(fmpcb_mat_entry(B, i, j), fmpcb_mat_entry(A, i, j), c, prec);
+}
+
 /* Solving */
 
 static __inline__ void
diff --git a/fmprb_mat.h b/fmprb_mat.h
index e604cb08..d6268168 100644
--- a/fmprb_mat.h
+++ b/fmprb_mat.h
@@ -111,6 +111,108 @@ void fmprb_mat_mul_threaded(fmprb_mat_t C, const fmprb_mat_t A, const fmprb_mat_
 
 void fmprb_mat_pow_ui(fmprb_mat_t B, const fmprb_mat_t A, ulong exp, long prec);
 
+/* Scalar arithmetic */
+
+static __inline__ void
+fmprb_mat_scalar_mul_2exp_si(fmprb_mat_t B, const fmprb_mat_t A, long c)
+{
+    long i, j;
+
+    for (i = 0; i < fmprb_mat_nrows(A); i++)
+        for (j = 0; j < fmprb_mat_ncols(A); j++)
+            fmprb_mul_2exp_si(fmprb_mat_entry(B, i, j), fmprb_mat_entry(A, i, j), c);
+}
+
+static __inline__ void
+fmprb_mat_scalar_addmul_si(fmprb_mat_t B, const fmprb_mat_t A, long c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmprb_mat_nrows(A); i++)
+        for (j = 0; j < fmprb_mat_ncols(A); j++)
+            fmprb_addmul_si(fmprb_mat_entry(B, i, j), fmprb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmprb_mat_scalar_mul_si(fmprb_mat_t B, const fmprb_mat_t A, long c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmprb_mat_nrows(A); i++)
+        for (j = 0; j < fmprb_mat_ncols(A); j++)
+            fmprb_mul_si(fmprb_mat_entry(B, i, j), fmprb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmprb_mat_scalar_div_si(fmprb_mat_t B, const fmprb_mat_t A, long c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmprb_mat_nrows(A); i++)
+        for (j = 0; j < fmprb_mat_ncols(A); j++)
+            fmprb_div_si(fmprb_mat_entry(B, i, j), fmprb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmprb_mat_scalar_addmul_fmpz(fmprb_mat_t B, const fmprb_mat_t A, const fmpz_t c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmprb_mat_nrows(A); i++)
+        for (j = 0; j < fmprb_mat_ncols(A); j++)
+            fmprb_addmul_fmpz(fmprb_mat_entry(B, i, j), fmprb_mat_entry(A, i, j), c, prec);
+}
+
+void
+fmprb_mat_scalar_mul_fmpz(fmprb_mat_t B, const fmprb_mat_t A, const fmpz_t c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmprb_mat_nrows(A); i++)
+        for (j = 0; j < fmprb_mat_ncols(A); j++)
+            fmprb_mul_fmpz(fmprb_mat_entry(B, i, j), fmprb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmprb_mat_scalar_div_fmpz(fmprb_mat_t B, const fmprb_mat_t A, const fmpz_t c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmprb_mat_nrows(A); i++)
+        for (j = 0; j < fmprb_mat_ncols(A); j++)
+            fmprb_div_fmpz(fmprb_mat_entry(B, i, j), fmprb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmprb_mat_scalar_addmul_fmprb(fmprb_mat_t B, const fmprb_mat_t A, const fmprb_t c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmprb_mat_nrows(A); i++)
+        for (j = 0; j < fmprb_mat_ncols(A); j++)
+            fmprb_addmul(fmprb_mat_entry(B, i, j), fmprb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmprb_mat_scalar_mul_fmprb(fmprb_mat_t B, const fmprb_mat_t A, const fmprb_t c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmprb_mat_nrows(A); i++)
+        for (j = 0; j < fmprb_mat_ncols(A); j++)
+            fmprb_mul(fmprb_mat_entry(B, i, j), fmprb_mat_entry(A, i, j), c, prec);
+}
+
+static __inline__ void
+fmprb_mat_scalar_div_fmprb(fmprb_mat_t B, const fmprb_mat_t A, const fmprb_t c, long prec)
+{
+    long i, j;
+
+    for (i = 0; i < fmprb_mat_nrows(A); i++)
+        for (j = 0; j < fmprb_mat_ncols(A); j++)
+            fmprb_div(fmprb_mat_entry(B, i, j), fmprb_mat_entry(A, i, j), c, prec);
+}
+
 /* Solving */
 
 static __inline__ void