passagemath-modules 10.6.31rc3__cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl

sage/modules/vector_modn_dense.pyx

@@ -0,0 +1,394 @@
+# sage_setup: distribution = sagemath-modules
+"""
+Vectors with integer mod `n` entries, with small `n`
+
+EXAMPLES::
+
+    sage: v = vector(Integers(8), [1,2,3,4,5])
+    sage: type(v)
+    <class 'sage.modules.vector_modn_dense.Vector_modn_dense'>
+    sage: v
+    (1, 2, 3, 4, 5)
+    sage: 3*v
+    (3, 6, 1, 4, 7)
+    sage: v*7
+    (7, 6, 5, 4, 3)
+    sage: -v
+    (7, 6, 5, 4, 3)
+    sage: v - v
+    (0, 0, 0, 0, 0)
+    sage: v + v
+    (2, 4, 6, 0, 2)
+    sage: v * v
+    7
+
+    sage: v = vector(Integers(8), [1,2,3,4,5])
+    sage: u = vector(Integers(8), [1,2,3,4,4])
+    sage: v - u
+    (0, 0, 0, 0, 1)
+    sage: u - v
+    (0, 0, 0, 0, 7)
+
+    sage: v = vector((Integers(5)(1),2,3,4,4))
+    sage: u = vector((Integers(5)(1),2,3,4,3))
+    sage: v - u
+    (0, 0, 0, 0, 1)
+    sage: u - v
+    (0, 0, 0, 0, 4)
+
+We make a large zero vector::
+
+    sage: k = Integers(8)^100000; k
+    Ambient free module of rank 100000 over Ring of integers modulo 8
+    sage: v = k(0)
+    sage: v[:10]
+    (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+
+We multiply a vector by a matrix::
+
+    sage: a = (GF(97)^5)(range(5))
+    sage: m = matrix(GF(97), 5, range(25))
+    sage: a*m
+    (53, 63, 73, 83, 93)
+
+TESTS::
+
+    sage: v = vector(Integers(8), [1,2,3,4,5])
+    sage: loads(dumps(v)) == v
+    True
+    sage: v = vector(Integers(389), [1,2,3,4,5])
+    sage: loads(dumps(v)) == v
+    True
+    sage: v = vector(Integers(next_prime(10^20)), [1,2,3,4,5])                          # needs sage.libs.pari
+    sage: loads(dumps(v)) == v
+    True
+
+    sage: K = GF(previous_prime(2^31))                                                  # needs sage.rings.finite_rings
+    sage: v = vector(K, [42]);  type(v[0])                                              # needs sage.rings.finite_rings
+    <class 'sage.rings.finite_rings.integer_mod.IntegerMod_int64'>
+    sage: ~v[0]                                                                         # needs sage.rings.finite_rings
+    2096353084
+
+    sage: K = GF(next_prime(2^31))                                                      # needs sage.rings.finite_rings
+    sage: v = vector(K, [42]);  type(v[0])                                              # needs sage.rings.finite_rings
+    <class 'sage.rings.finite_rings.integer_mod.IntegerMod_gmp'>
+    sage: ~v[0]                                                                         # needs sage.rings.finite_rings
+    1482786336
+
+    sage: w = vector(GF(11), [-1,0,0,0])
+    sage: w.set_immutable()
+    sage: isinstance(hash(w), int)
+    True
+
+Test that :issue:`28042` is fixed::
+
+    sage: # needs sage.rings.finite_rings
+    sage: p = 193379
+    sage: K = GF(p)
+    sage: a = K(1)
+    sage: b = K(191495)
+    sage: c = K(109320)
+    sage: d = K(167667)
+    sage: e = 103937
+    sage: a*c + b*d - e
+    102041
+    sage: vector([a,b]) * vector([c,d]) - e
+    102041
+    sage: type(vector([a,b]) * vector([c,d]))
+    <class 'sage.rings.finite_rings.integer_mod.IntegerMod_int64'>
+
+AUTHOR:
+
+- William Stein (2007)
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2007 William Stein <wstein@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from cysignals.memory cimport check_allocarray, sig_free
+from sage.structure.richcmp cimport rich_to_bool
+from sage.rings.finite_rings.stdint cimport INTEGER_MOD_INT64_LIMIT
+
+MAX_MODULUS = INTEGER_MOD_INT64_LIMIT
+
+from sage.rings.finite_rings.integer_mod cimport (
+    IntegerMod_int, IntegerMod_int64,
+    IntegerMod_abstract, use_32bit_type)
+
+cdef mod_int ivalue(IntegerMod_abstract x) except -1:
+    if type(x) is IntegerMod_int:
+        return (<IntegerMod_int>x).ivalue
+    elif type(x) is IntegerMod_int64:
+        return (<IntegerMod_int64>x).ivalue
+    else:
+        raise TypeError("non-fixed size integer")
+
+from sage.structure.element cimport Element, Vector
+
+cimport sage.modules.free_module_element as free_module_element
+
+
+cdef class Vector_modn_dense(free_module_element.FreeModuleElement):
+    cdef _new_c(self):
+        cdef Vector_modn_dense y
+        y = Vector_modn_dense.__new__(Vector_modn_dense)
+        y._init(self._degree, self._parent, self._p)
+        return y
+
+    cdef bint is_dense_c(self) noexcept:
+        return 1
+
+    cdef bint is_sparse_c(self) noexcept:
+        return 0
+
+    def __copy__(self):
+        cdef Vector_modn_dense y
+        y = self._new_c()
+        cdef Py_ssize_t i
+        for i from 0 <= i < self._degree:
+            y._entries[i] = self._entries[i]
+        return y
+
+    cdef _init(self, Py_ssize_t degree, parent, mod_int p):
+        self._degree = degree
+        self._parent = parent
+        self._p = p
+        self._entries = <mod_int *>check_allocarray(degree, sizeof(mod_int))
+
+    def __cinit__(self, parent=None, x=None, coerce=True, copy=True):
+        self._entries = NULL
+        self._is_immutable = 0
+        if parent is not None:
+            self._init(parent.degree(), parent, parent.base_ring().order())
+
+    def __init__(self, parent, x, coerce=True, copy=True):
+        """
+        Create an element.
+
+        TESTS:
+
+        Note that ``coerce=False`` is dangerous::
+
+            sage: V = VectorSpace(GF(7), 3)
+            sage: v = V([2, 9, -5], coerce=False)
+            sage: v[0] == v[1]
+            False
+            sage: v[0] + 1 == v[1] + 1
+            True
+            sage: v[0] == v[2]
+            False
+        """
+        cdef Py_ssize_t i
+        cdef mod_int a
+        if isinstance(x, range):
+            x = tuple(x)
+        if isinstance(x, (list, tuple)):
+            if len(x) != self._degree:
+                raise TypeError("x must be a list of the right length")
+            if coerce:
+                R = parent.base_ring()
+                for i from 0 <= i < self._degree:
+                    a = int(R(x[i]))
+                    self._entries[i] = a
+            else:
+                for i from 0 <= i < self._degree:
+                    self._entries[i] = x[i]
+            return
+        if x != 0:
+            raise TypeError("can't initialize vector from nonzero non-list")
+        else:
+            for i from 0 <= i < self._degree:
+                self._entries[i] = 0
+
+    def __dealloc__(self):
+        sig_free(self._entries)
+
+    cpdef _richcmp_(left, right, int op):
+        """
+        EXAMPLES::
+
+            sage: v = vector(GF(5), [0,0,0,0])
+            sage: v == 0
+            True
+            sage: v == 1
+            False
+            sage: v == v
+            True
+            sage: w = vector(GF(11), [-1,0,0,0])
+            sage: w == w
+            True
+        """
+        cdef Py_ssize_t i
+        cdef mod_int l, r
+        for i in range(left.degree()):
+            l = left._entries[i]
+            r = (<Vector_modn_dense>right)._entries[i]
+            if l < r:
+                return rich_to_bool(op, -1)
+            elif l > r:
+                return rich_to_bool(op, 1)
+        return rich_to_bool(op, 0)
+
+    cdef get_unsafe(self, Py_ssize_t i):
+        """
+        EXAMPLES::
+
+            sage: R = Integers(7)
+            sage: v = vector(R, [1,2,3]); v
+            (1, 2, 3)
+            sage: v[0]
+            1
+            sage: v[2]
+            3
+            sage: v[-2]
+            2
+            sage: v[0:2]
+            (1, 2)
+            sage: v[5]
+            Traceback (most recent call last):
+            ...
+            IndexError: vector index out of range
+            sage: v[-5]
+            Traceback (most recent call last):
+            ...
+            IndexError: vector index out of range
+        """
+        cdef IntegerMod_int n
+        cdef IntegerMod_int64 m
+
+        if use_32bit_type(self._p):
+            n = IntegerMod_int.__new__(IntegerMod_int)
+            IntegerMod_abstract.__init__(n, self.base_ring())
+            n.ivalue = self._entries[i]
+            return n
+        else:
+            m = IntegerMod_int64.__new__(IntegerMod_int64)
+            IntegerMod_abstract.__init__(m, self.base_ring())
+            m.ivalue = self._entries[i]
+            return m
+
+    cdef int set_unsafe(self, Py_ssize_t i, value) except -1:
+        """
+        EXAMPLES::
+
+            sage: R = Integers(7)
+            sage: v = vector(R, [1,2,3]); v
+            (1, 2, 3)
+            sage: v[0] = 7^7
+            sage: v
+            (0, 2, 3)
+        """
+        self._entries[i] = ivalue(<IntegerMod_abstract>value)
+
+    def __reduce__(self):
+        return unpickle_v1, (self._parent, self.list(), self._degree,
+                             self._p, not self._is_immutable)
+
+    cpdef _add_(self, right):
+        cdef Vector_modn_dense z, r
+        r = right
+        z = self._new_c()
+        cdef Py_ssize_t i
+        for i from 0 <= i < self._degree:
+            z._entries[i] = (self._entries[i] + r._entries[i]) % self._p
+        return z
+
+    cpdef _sub_(self, right):
+        cdef Vector_modn_dense z, r
+        r = right
+        z = self._new_c()
+        cdef Py_ssize_t i
+        for i from 0 <= i < self._degree:
+            z._entries[i] = (self._p + self._entries[i] - r._entries[i]) % self._p
+        return z
+
+    cpdef _dot_product_(self, Vector right):
+        cdef size_t i
+        cdef IntegerMod_int n
+        cdef IntegerMod_int64 m
+        cdef Vector_modn_dense r = right
+
+        if use_32bit_type(self._p):
+            n = IntegerMod_int.__new__(IntegerMod_int)
+            IntegerMod_abstract.__init__(n, self.base_ring())
+            n.ivalue = 0
+            for i in range(self._degree):
+                n.ivalue = (n.ivalue + self._entries[i] * r._entries[i]) % self._p
+            return n
+        else:
+            m = IntegerMod_int64.__new__(IntegerMod_int64)
+            IntegerMod_abstract.__init__(m, self.base_ring())
+            m.ivalue = 0
+            for i in range(self._degree):
+                m.ivalue = (m.ivalue + self._entries[i] * r._entries[i]) % self._p
+            return m
+
+    cpdef _pairwise_product_(self, Vector right):
+        """
+        EXAMPLES::
+
+           sage: v = vector(Integers(8), [2,3]); w = vector(Integers(8), [2,5])
+           sage: v * w
+           3
+           sage: w * v
+           3
+        """
+        cdef Vector_modn_dense z, r
+        r = right
+        z = self._new_c()
+        cdef Py_ssize_t i
+        for i from 0 <= i < self._degree:
+            z._entries[i] = (self._entries[i] * r._entries[i]) % self._p
+        return z
+
+    cpdef _lmul_(self, Element left):
+        cdef Vector_modn_dense z
+
+        cdef mod_int a = ivalue(left)
+        z = self._new_c()
+        cdef Py_ssize_t i
+
+        for i from 0 <= i < self._degree:
+            z._entries[i] = (self._entries[i] * a) % self._p
+        return z
+
+    cpdef _neg_(self):
+        cdef Vector_modn_dense z
+        z = self._new_c()
+        cdef Py_ssize_t i
+        for i from 0 <= i < self._degree:
+            if self._entries[i] > 0:
+                z._entries[i] = self._p - self._entries[i]
+            else:
+                z._entries[i] = 0
+        return z
+
+
+def unpickle_v0(parent, entries, degree, p):
+    # If you think you want to change this function, don't.
+    # Instead make a new version with a name like
+    #    make_FreeModuleElement_generic_dense_v1
+    # and changed the reduce method below.
+    cdef Vector_modn_dense v
+    v = Vector_modn_dense.__new__(Vector_modn_dense)
+    v._init(degree, parent, p)
+    for i from 0 <= i < degree:
+        v._entries[i] = entries[i]
+    return v
+
+
+def unpickle_v1(parent, entries, degree, p, is_mutable):
+    cdef Vector_modn_dense v
+    v = Vector_modn_dense.__new__(Vector_modn_dense)
+    v._init(degree, parent, p)
+    for i from 0 <= i < degree:
+        v._entries[i] = entries[i]
+    v._is_immutable = not is_mutable
+    return v

sage/modules/vector_modn_sparse.pxd

@@ -0,0 +1,21 @@
+# sage_setup: distribution = sagemath-modules
+from sage.rings.finite_rings.stdint cimport *
+
+cdef struct c_vector_modint:
+    int_fast64_t *entries
+    int p
+    Py_ssize_t *positions
+    Py_ssize_t degree
+    Py_ssize_t num_nonzero
+
+cdef int allocate_c_vector_modint(c_vector_modint* v, Py_ssize_t num_nonzero) except -1
+cdef int init_c_vector_modint(c_vector_modint* v, int p, Py_ssize_t degree, Py_ssize_t num_nonzero) except -1
+cdef void clear_c_vector_modint(c_vector_modint* v) noexcept
+cdef Py_ssize_t binary_search0_modn(Py_ssize_t* v, Py_ssize_t n, int_fast64_t x) noexcept
+cdef Py_ssize_t binary_search_modn(Py_ssize_t* v, Py_ssize_t n, int_fast64_t x, Py_ssize_t* ins) noexcept
+cdef int_fast64_t get_entry(c_vector_modint* v, Py_ssize_t n) except -1
+cdef bint is_entry_zero_unsafe(c_vector_modint* v, Py_ssize_t n) noexcept
+cdef object to_list(c_vector_modint* v)
+cdef int set_entry(c_vector_modint* v, Py_ssize_t n, int_fast64_t x) except -1
+cdef int add_c_vector_modint_init(c_vector_modint* sum, c_vector_modint* v, c_vector_modint* w, int multiple) except -1
+cdef int scale_c_vector_modint(c_vector_modint* v, int_fast64_t scalar) except -1

sage/modules/vector_modn_sparse.pyx

@@ -0,0 +1,298 @@
+# sage_setup: distribution = sagemath-modules
+#############################################################################
+#       Copyright (C) 2004, 2007 William Stein <wstein@gmail.com>
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  The full text of the GPL is available at:
+#                  https://www.gnu.org/licenses/
+#############################################################################
+
+from cysignals.memory cimport sig_malloc, sig_free
+
+
+cdef int allocate_c_vector_modint(c_vector_modint* v, Py_ssize_t num_nonzero) except -1:
+    """
+    Allocate memory for a c_vector_modint -- most user code won't call this.
+    """
+    v.entries = <int_fast64_t*>sig_malloc(num_nonzero*sizeof(int_fast64_t))
+    if v.entries == NULL:
+        raise MemoryError("error allocating memory")
+    v.positions = <Py_ssize_t*>sig_malloc(num_nonzero*sizeof(Py_ssize_t))
+    if v.positions == NULL:
+        sig_free(v.entries)
+        raise MemoryError("error allocating memory")
+    return 0
+
+
+cdef int init_c_vector_modint(c_vector_modint* v, int p, Py_ssize_t degree,
+                              Py_ssize_t num_nonzero) except -1:
+    """
+    Initialize a c_vector_modint.
+    """
+    if (allocate_c_vector_modint(v, num_nonzero) == -1):
+        raise MemoryError("error allocating memory for sparse vector")
+    if p > 46340:
+        clear_c_vector_modint(v)
+        raise OverflowError("the prime must be <= 46340")
+    v.num_nonzero = num_nonzero
+    v.degree = degree
+    v.p = p
+    return 0
+
+
+cdef void clear_c_vector_modint(c_vector_modint* v) noexcept:
+    sig_free(v.entries)
+    sig_free(v.positions)
+
+
+cdef Py_ssize_t binary_search0_modn(Py_ssize_t* v, Py_ssize_t n, int_fast64_t x) noexcept:
+    """
+    Find the position of the int x in the array v, which has length n.
+
+    Return -1 if x is not in the array v.
+    """
+    if n == 0:
+        return -1
+
+    cdef Py_ssize_t i, j, k
+    i = 0
+    j = n-1
+    while i <= j:
+        if i == j:
+            if v[i] == x:
+                return i
+            return -1
+        k = (i+j)/2
+        if v[k] > x:
+            j = k-1
+        elif v[k] < x:
+            i = k+1
+        else:   # only possibility is that v[k] == x
+            return k
+    return -1
+
+
+cdef Py_ssize_t binary_search_modn(Py_ssize_t* v, Py_ssize_t n, int_fast64_t x, Py_ssize_t* ins) noexcept:
+    """
+    Find the position of the integer x in the array v, which has length n.
+
+    Return -1 if x is not in the array v, and in this case ins is
+    set equal to the position where x should be inserted in order to
+    obtain an ordered array.
+    """
+    if n == 0:
+        ins[0] = 0
+        return -1
+
+    cdef Py_ssize_t i, j, k
+    i = 0
+    j = n-1
+    while i <= j:
+        if i == j:
+            if v[i] == x:
+                ins[0] = i
+                return i
+            if v[i] < x:
+                ins[0] = i + 1
+            else:
+                ins[0] = i
+            return -1
+        k = (i+j)/2
+        if v[k] > x:
+            j = k-1
+        elif v[k] < x:
+            i = k+1
+        else:   # only possibility is that v[k] == x
+            ins[0] = k
+            return k
+    ins[0] = j+1
+    return -1
+
+
+cdef int_fast64_t get_entry(c_vector_modint* v, Py_ssize_t n) except -1:
+    """
+    Return the n-th entry of the sparse vector v.
+
+    This would be v[n] in Python syntax.
+    """
+    if n >= v.degree or n < 0:
+        raise IndexError("index must be between 0 and the degree minus 1")
+    cdef Py_ssize_t m
+    m = binary_search0_modn(v.positions, v.num_nonzero, n)
+    if m == -1:
+        return 0
+    return v.entries[m]
+
+cdef bint is_entry_zero_unsafe(c_vector_modint* v, Py_ssize_t n) noexcept:
+    """
+    Return if the ``n``-th entry of the sparse vector ``v`` is zero.
+
+    This is meant for internal use only. If ``n`` is not valid, then
+    this might lead to a segfault.
+    """
+    return binary_search0_modn(v.positions, v.num_nonzero, n) == -1
+
+cdef object to_list(c_vector_modint* v):
+    """
+    Return a Python list of 2-tuples (i,x), where x=v[i] runs
+    through the nonzero elements of x, in order.
+    """
+    cdef object X
+    cdef Py_ssize_t i
+    X = []
+    for i in range(v.num_nonzero):
+        X.append((v.positions[i], v.entries[i]))
+    return X
+
+
+cdef int set_entry(c_vector_modint* v, Py_ssize_t n, int_fast64_t x) except -1:
+    """
+    Set the n-th component of the sparse vector v equal to x.
+
+    This would be v[n] = x in Python syntax.
+    """
+    if n < 0 or n >= v.degree:
+        raise IndexError("index (=%s) must be between 0 and %s" % (n, v.degree-1))
+    cdef Py_ssize_t i, m, ins
+    cdef Py_ssize_t *pos
+    cdef int_fast64_t *e
+
+    x = x % v.p
+    if x < 0:
+        x = x + v.p
+    m = binary_search_modn(v.positions, v.num_nonzero, n, &ins)
+
+    if m != -1:
+        # The position n was found in the array of positions.
+        # Now there are two cases:
+        #   1. x =/= 0, which is easy, and
+        #   2. x = 0, in which case we have to recopy
+        #      positions and entries, without the m-th
+        #      element, and change num_nonzero.
+        if x != 0:   # case 1
+            v.entries[m] = x
+        else:        # case 2
+            e = v.entries
+            pos = v.positions
+            allocate_c_vector_modint(v, v.num_nonzero - 1)
+            for i in range(m):
+                v.entries[i] = e[i]
+                v.positions[i] = pos[i]
+            for i from m < i < v.num_nonzero:
+                v.entries[i-1] = e[i]
+                v.positions[i-1] = pos[i]
+            sig_free(e)
+            sig_free(pos)
+            v.num_nonzero = v.num_nonzero - 1
+    else:
+        # Allocate new memory and copy over elements from the
+        # old array.  This is similar to case 2 above,
+        # except we are inserting a new entry rather than
+        # deleting an old one.  The new entry should be inserted
+        # at position ins, which was computed using binary search.
+        #
+        # There is one exception -- if the new entry is 0, we
+        # do nothing and return.
+        if x == 0:
+            return 0
+        v.num_nonzero = v.num_nonzero + 1
+        e = v.entries
+        pos = v.positions
+        allocate_c_vector_modint(v, v.num_nonzero)
+        for i in range(ins):
+            v.entries[i] = e[i]
+            v.positions[i] = pos[i]
+        v.entries[ins] = x
+        v.positions[ins] = n
+        for i from ins < i < v.num_nonzero:
+            v.entries[i] = e[i-1]
+            v.positions[i] = pos[i-1]
+        sig_free(e)
+        sig_free(pos)
+
+
+cdef int add_c_vector_modint_init(c_vector_modint* sum, c_vector_modint* v,
+                                  c_vector_modint* w, int multiple) except -1:
+    """
+    Set sum = v + multiple*w.
+    """
+    if v.p != w.p:
+        raise ArithmeticError("the vectors must be modulo the same prime")
+    if v.degree != w.degree:
+        raise ArithmeticError("the vectors must have the same degree")
+
+    cdef int s
+    cdef Py_ssize_t nz, i, j, k
+    cdef c_vector_modint* z
+
+    multiple = multiple % v.p    # need this to avoid overflow.
+    if multiple < 0:
+        multiple = multiple + v.p
+
+    z = sum
+    # ALGORITHM:
+    # 1. Allocate enough memory to hold the union of the two
+    #    lists of positions.  We allocate the sum of the number
+    #    of positions of both (up to the degree), to avoid
+    #    having to make two passes.  This might be slightly wasteful of
+    #    memory, but is faster.
+    # 2. Move along the entries of v and w, copying them into the
+    #    new position / entry array.  When position are the same,
+    #    add modulo p.
+    # 3. Set num_nonzero and return success code.
+
+    # 1. Allocate memory:
+    nz = v.num_nonzero + w.num_nonzero
+    if nz > v.degree:
+        nz = v.degree
+    init_c_vector_modint(z, v.p, v.degree, nz)
+    # 2. Merge entries
+    i = 0  # index into entries of v
+    j = 0  # index into entries of w
+    k = 0  # index into z (the vector we are creating)
+    while i < v.num_nonzero or j < w.num_nonzero:
+        if i >= v.num_nonzero:   # just copy w in
+            z.positions[k] = w.positions[j]
+            z.entries[k] = (multiple * w.entries[j]) % v.p
+            j = j + 1
+            k = k + 1
+        elif j >= w.num_nonzero:  # just copy v in
+            z.positions[k] = v.positions[i]
+            z.entries[k] = v.entries[i]
+            i = i + 1
+            k = k + 1
+        elif v.positions[i] < w.positions[j]:  # copy entry from v in
+            z.positions[k] = v.positions[i]
+            z.entries[k] = v.entries[i]
+            i = i + 1
+            k = k + 1
+        elif v.positions[i] > w.positions[j]: # copy entry from w in
+            s = (multiple * w.entries[j]) % v.p
+            if s != 0:
+                z.positions[k] = w.positions[j]
+                z.entries[k] = s
+                k = k + 1
+            j = j + 1
+        else:                                 # equal, so add and copy
+            s = (v.entries[i] + multiple*w.entries[j]) % v.p
+            if s != 0:
+                z.positions[k] = v.positions[i]
+                z.entries[k] = s
+                k = k + 1     # only increment if sum is nonzero!
+            i = i + 1
+            j = j + 1
+    z.num_nonzero = k
+    return 0
+
+
+cdef int scale_c_vector_modint(c_vector_modint* v, int_fast64_t scalar) except -1:
+    scalar = scalar % v.p
+    if scalar == 0:
+        clear_c_vector_modint(v)
+        init_c_vector_modint(v, v.p, v.degree, 0)
+        return 0
+    if scalar < 0:
+        scalar = scalar + v.p
+    cdef Py_ssize_t i
+    for i in range(v.num_nonzero):
+        v.entries[i] = (v.entries[i] * scalar) % v.p
+    return 0