code: def qspline1d_eval(cj, newx, dx=1.0, x0=0):
      """Evaluate a quadratic spline at the new set of points.
  
      Parameters
      ----------
      cj : ndarray
          Quadratic spline coefficients
      newx : ndarray
          New set of points.
      dx : float, optional
          Old sample-spacing, the default value is 1.0.
      x0 : int, optional
          Old origin, the default value is 0.
  
      Returns
      -------
      res : ndarray
          Evaluated a quadratic spline points.
  
      See Also
      --------
      qspline1d : Compute quadratic spline coefficients for rank-1 array.
  
      Notes
      -----
      `dx` is the old sample-spacing while `x0` was the old origin. In
      other-words the old-sample points (knot-points) for which the `cj`
      represent spline coefficients were at equally-spaced points of::
  
        oldx = x0 + j*dx  j=0...N-1, with N=len(cj)
  
      Edges are handled using mirror-symmetric boundary conditions.
  
      Examples
      --------
      We can filter a signal to reduce and smooth out high-frequency noise with
      a quadratic spline:
  
      >>> import numpy as np
      >>> import matplotlib.pyplot as plt
      >>> from scipy.signal import qspline1d, qspline1d_eval
      >>> rng = np.random.default_rng()
      >>> sig = np.repeat([0., 1., 0.], 100)
      >>> sig += rng.standard_normal(len(sig))*0.05  # add noise
      >>> time = np.linspace(0, len(sig))
      >>> filtered = qspline1d_eval(qspline1d(sig), time)
      >>> plt.plot(sig, label="signal")
      >>> plt.plot(time, filtered, label="filtered")
      >>> plt.legend()
      >>> plt.show()
  
      """
      newx = (asarray(newx) - x0) / dx
      res = zeros_like(newx)
      if res.size == 0:
          return res
      N = len(cj)
      cond1 = newx < 0
      cond2 = newx > (N - 1)
      cond3 = ~(cond1 | cond2)
      # handle general mirror-symmetry
      res[cond1] = qspline1d_eval(cj, -newx[cond1])
      res[cond2] = qspline1d_eval(cj, 2 * (N - 1) - newx[cond2])
      newx = newx[cond3]
      if newx.size == 0:
          return res
      result = zeros_like(newx)
      jlower = floor(newx - 1.5).astype(int) + 1
      for i in range(3):
          thisj = jlower + i
          indj = thisj.clip(0, N - 1)  # handle edge cases
          result += cj[indj] * _quadratic(newx - thisj)
      res[cond3] = result
      return res
  
file_path: scipy/scipy/signal/_bsplines.py
imports: from numpy import asarray, pi, zeros_like, array, arctan2, tan, ones, arange, floor, r_, atleast_1d, sqrt, exp, greater, cos, add, sin
  from ._spline import cspline2d, sepfir2d
  from ._signaltools import lfilter, sosfilt, lfiltic
  from scipy.interpolate import BSpline
label_desc: Use image node_id 14 for calling a global function with example usage: qspline1d_eval(cj, newx, dx, x0) and returns: res, res, res