Returns the maximum value that is accepted by the `speed_sp` attribute. This
        may be slightly different than the maximum speed that a particular motor can
        reach - it's the maximum theoretical speed.
12980
def max_speed(self):
        
        (self._max_speed, value) = self.get_cached_attr_int(self._max_speed, 'max_speed')
        return value
743519
public int getMaximumParallelism() {
		int maxParallelism = -1;
		for (JobVertex vertex : taskVertices.values()) {
			maxParallelism = Math.max(vertex.getParallelism(), maxParallelism);
		}
		return maxParallelism;
	}
1297864
public int getMaxLength()
    {
        if (m_iMaxLength == Constants.DEFAULT_FIELD_LENGTH)
        {
            m_iMaxLength = 20;
            if (m_classData == Short.class)
                m_iMaxLength = 4;
            else if (m_classData == Integer.class)
                m_iMaxLength = 8;
            else if (m_classData == Float.class)
                m_iMaxLength = 8;
            else if (m_classData == Double.class)
                m_iMaxLength = 15;
            else if (m_classData == java.util.Date.class)
                m_iMaxLength = 15;
            else if (m_classData == String.class)
                m_iMaxLength = 30;
            else if (m_classData == Boolean.class)
                m_iMaxLength = 10;
        }
        return m_iMaxLength;
    }
327136
synchronized Weight getMaximumFinish() {
        if (calcMaxFinish == null) {
            // Find the longest distance from time zero to a finish.
            Weight result = WeightFactory.NEG_INFINITY;
            if (shortestDistancesFromTimeZeroSource == null) {
                shortestDistancesFromTimeZeroSource = BellmanFord.calcShortestDistances(timeZero, directedGraph,
                        BellmanFord.Mode.SOURCE);
                if (shortestDistancesFromTimeZeroSource == null) {
                    throw new IllegalStateException("Negative cycle detected!");
                }
            }
            for (int i = 0, n = intervals.size(); i < n; i++) {
                Object finish = intervals.get(i).getFinish();
                result = Weight.max(result,
                        (Weight) shortestDistancesFromTimeZeroSource.get(finish));
            }
            calcMaxFinish = result;
        }

        return calcMaxFinish;
    }
557740
def farthest(self, dt1, dt2, *dts):
        from functools import reduce

        
        dt1 = pendulum.instance(dt1)
        dt2 = pendulum.instance(dt2)

        dts = [dt1, dt2] + [pendulum.instance(x) for x in dts]
        dts = [(abs(self - dt), dt) for dt in dts]

        return max(dts)[1]
982415
def MaxSpeed(self, speed):
        '  '
        spi.SPI_write_byte(self.CS, 0x07)       # Max Speed setup 
        spi.SPI_write_byte(self.CS, 0x00)
        spi.SPI_write_byte(self.CS, speed)
3838
def max_spline_jump(self):
        
        sp = self.spline()
        return max(self.energies - sp(range(len(self.energies))))
564245
def reach_max_num(self):
        
        if self.signal.get('reach_max_num'):
            return True
        if self.max_num > 0 and self.fetched_num >= self.max_num:
            return True
        else:
            return False
527092
public Integer getMaxIdleTime()
   {
      if (childNode.getTextValueForPatternName("max-idle-time") != null && !childNode.getTextValueForPatternName("max-idle-time").equals("null")) {
         return Integer.valueOf(childNode.getTextValueForPatternName("max-idle-time"));
      }
      return null;
   }
699070
def compute(self, motor_pct: float, tm_diff: float) -> float:
        

        appliedVoltage = self._nominalVoltage * motor_pct
        appliedVoltage = math.copysign(
            max(abs(appliedVoltage) - self._vintercept, 0), appliedVoltage
        )

        # Heun's method (taken from Ether's drivetrain calculator)
        # -> yn+1 = yn + (h/2) (f(xn, yn) + f(xn + h, yn +  h f(xn, yn)))
        a0 = self.acceleration
        v0 = self.velocity

        # initial estimate for next velocity/acceleration
        v1 = v0 + a0 * tm_diff
        a1 = (appliedVoltage - self._kv * v1) / self._ka

        # corrected trapezoidal estimate
        v1 = v0 + (a0 + a1) * 0.5 * tm_diff
        a1 = (appliedVoltage - self._kv * v1) / self._ka
        self.position += (v0 + v1) * 0.5 * tm_diff

        self.velocity = v1
        self.acceleration = a1

        return self.velocity
909652
public static int cudnnSoftmaxBackward(
        cudnnHandle handle, 
        int algo, 
        int mode, 
        Pointer alpha, 
        cudnnTensorDescriptor yDesc, 
        Pointer y, 
        cudnnTensorDescriptor dyDesc, 
        Pointer dy, 
        Pointer beta, 
        cudnnTensorDescriptor dxDesc, 
        Pointer dx)
    {
        return checkResult(cudnnSoftmaxBackwardNative(handle, algo, mode, alpha, yDesc, y, dyDesc, dy, beta, dxDesc, dx));
    }
1188960
function getMinMax() {
  var minPt = pts[0];
  var maxPt = pts[0];
  for (var i=1; i<pts.length; i++) {
    minPt = minPt.$min( pts[i] );
  }
  for (i=1; i<pts.length; i++) {
    maxPt = maxPt.$max( pts[i] );
  }
  nextRect.set( minPt).to( maxPt );
}
616726
public static int getMaxValue(int... nums) {
        int max = 0;
        int last = nums.length - 1;
        for (int i = 0; i < last; i += ValueConsts.TWO_INT) {
            max = Integer.max(max, Integer.max(nums[i], nums[i + 1]));
        }
        return Integer.max(max, nums[last]);
    }
1187284
def speed_info(self):
        
        speed_info = structs.JLinkSpeedInfo()
        self._dll.JLINKARM_GetSpeedInfo(ctypes.byref(speed_info))
        return speed_info
1355048
def max(cls):
        """"""
        max_recid = db.session.query(func.max(cls.recid)).scalar()
        return max_recid if max_recid else 0
753406
private double getMaxSelectedValue() {
        double max = Double.MIN_VALUE;

        for (int i = 0; i < this.measures.length; i++) {
            if (this.measures[i].getMaxValue(this.measureSelected) > max) {
                max = this.measures[i].getMaxValue(this.measureSelected);
            }
        }
        return max;
    }
503572
public function &GetMaxVat()
    {
        $iPointer = $this->getItemPointer();
        $oMaxVatItem = null;
        $this->GoToStart();
        while ($oItem = &$this->Next()) {
            $oCurrentVat = $oItem->GetVat();
            if (!is_null($oCurrentVat)) {
                if (is_null($oMaxVatItem)) {
                    $oMaxVatItem = $oCurrentVat;
                } elseif ($oMaxVatItem->fieldVatPercent < $oCurrentVat->fieldVatPercent) {
                    $oMaxVatItem = $oCurrentVat;
                }
            }
        }
        $this->setItemPointer($iPointer);

        return $oMaxVatItem;
    }