Berechnet die Pruefziffer des uebergebenen Wertes. Die Berechung stammt
aus https://de.wikipedia.org/wiki/Luhn-Algorithmus#Java.

@param wert Wert (ohne Pruefziffer)
@return errechnete Pruefziffer
351788
public String berechnePruefziffer(String wert) {
        int sum = getQuersumme(wert);
        return Integer.toString((10 - sum % 10) % 10);
    }
671468
public function &c() {
    $args = func_get_args();
    if (count($args) > $this->argsCount) {
      $rel = array_pop($args); // rel ist übergeben worden
    } else {
      $rel = 0;
    }
    for ($i=0; $i < $this->argsCount; $i++) {
      $this->values[$i][] = $args[$i];
    }

    $key = $this->getKey($args);
    if (!array_key_exists($key,$this->counts)) {
      $this->counts[$key] = $this->initCount;
    }
    $ref =& $this->counts[$key];
    $ref += $rel;
    return $ref;
  }
75226
public org.tensorflow.framework.OpDef.AttrDefOrBuilder getAttrOrBuilder(
      int index) {
    return attr_.get(index);
  }
924434
@Nonnull
  @ReturnsMutableCopy
  public Matrix getH ()
  {
    final Matrix aNewMatrix = new Matrix (m_nRows, m_nCols);
    final double [] [] aNewArray = aNewMatrix.internalGetArray ();
    for (int nRow = 0; nRow < m_nRows; nRow++)
    {
      final double [] aSrcRow = m_aQR[nRow];
      final double [] aDstRow = aNewArray[nRow];
      for (int nCol = 0; nCol < m_nCols; nCol++)
      {
        aDstRow[nCol] = (nRow >= nCol ? aSrcRow[nCol] : 0d);
      }
    }
    return aNewMatrix;
  }
967310
public StrBuilder append(final String str) {
        if (str == null) {
            return appendNull();
        }
        final int strLen = str.length();
        if (strLen > 0) {
            final int len = length();
            ensureCapacity(len + strLen);
            str.getChars(0, strLen, buffer, len);
            size += strLen;
        }
        return this;
    }
110823
public RetryerBuilder<V> retryIfException() {
        rejectionPredicate = Predicates.or(rejectionPredicate, new ExceptionClassPredicate<V>(Exception.class));
        return this;
    }
1288947
public WritableByteChannel asWritableByteChannel() {

		// Bufferless/direct output
		if (packetSize < 2) {
			return new WritableByteChannel() {

				@Override
				public final boolean isOpen() {
					return !closed.get();
				}

				@Override
				public final void close() {
					sendClose();
				}

				@Override
				public final int write(ByteBuffer src) {
					try {
						int len = src.remaining();
						if (len > 0) {
							byte[] packet = new byte[len];
							src.get(packet);
							sendData(packet);
						}
						return len;
					} catch (Throwable cause) {
						try {
							sendError(cause);
						} catch (Throwable ignored) {
						}
						throw cause;
					}
				}

				@Override
				protected final void finalize() throws Throwable {
					close();
				}

			};
		}

		// Buffered output
		final OutputStream out = asOutputStream();
		return new WritableByteChannel() {

			@Override
			public final boolean isOpen() {
				return !closed.get();
			}

			@Override
			public final void close() throws IOException {
				out.flush();
				out.close();
			}

			@Override
			public final int write(ByteBuffer src) throws IOException {
				try {
					int len = src.remaining();
					if (len > 0) {
						byte[] packet = new byte[len];
						src.get(packet);
						out.write(packet);
					}
					return len;
				} catch (Throwable cause) {
					try {
						sendError(cause);
					} catch (Throwable ignored) {
					}
					throw cause;
				}
			}

		};
	}
826478
public java.util.List<? extends org.tensorflow.framework.OpDef.AttrDefOrBuilder> 
      getAttrOrBuilderList() {
    return attr_;
  }
1015633
public static <T> ObservableTransformer<T,T> doOnErrorCountFx(Consumer<Integer> onError) {
        return obs -> obs.compose(doOnErrorCount(i -> runOnFx(i,onError)));
    }
82440
public static <T> Set<T> iteratorToSet(Iterator<T> iterator) {
        Set<T> set = new HashSet<>();
        while (iterator.hasNext()) {
            set.add(iterator.next());
        }
        return set;
    }
793405
public static function forError(): OutputStream
    {
        if (null === self::$err) {
            self::$err = self::create('php://stderr');
        }

        return self::$err;
    }
1249606
public static <T> Iterator<T> singleIterator(T t) {
        Require.nonNull(t, "t");
        return Collections.singleton(t).iterator();
    }
660739
public static DoubleBinding cbrt(final ObservableDoubleValue a) {
        return createDoubleBinding(() -> Math.cbrt(a.get()), a);
    }
811567
public NodeIterator nodeset() throws javax.xml.transform.TransformerException
  {
    return (m_origObj instanceof NodeIterator) 
                   ? (NodeIterator)m_origObj : super.nodeset();      
  }
600329
public RowMajorMatrixIterator nonZeroRowMajorIterator() {
        return new RowMajorMatrixIterator(rows, columns) {
            private long limit = (long) rows * columns;
            private long i = -1;

            @Override
            public int rowIndex() {
                return (int) (i / columns);
            }

            @Override
            public int columnIndex() {
                return (int) (i - ((i / columns) * columns));
            }

            @Override
            public double get() {
                return SparseMatrix.this.get(rowIndex(), columnIndex());
            }

            @Override
            public void set(double value) {
                SparseMatrix.this.set(rowIndex(), columnIndex(), value);
            }

            @Override
            public boolean hasNext() {
                while (i + 1 < limit) {
                    i++;
                    if (SparseMatrix.this.nonZeroAt(rowIndex(), columnIndex())) {
                        i--;
                        break;
                    }
                }

                return i + 1 < limit;
            }

            @Override
            public Double next() {
                if(!hasNext()) {
                    throw new NoSuchElementException();
                }
                i++;
                return get();
            }
        };
    }
398513
public static <T> FlowableTransformer<T,T> doOnErrorCount(Consumer<Integer> onError) {
        return obs -> obs.lift(new FlowableEmissionCounter<>(new CountObserver(null,null,onError)));
    }
1214397
public static java.util.Collection<?> values(Struct sct) {
	ArrayList<Object> arr = new ArrayList<Object>();
	// Key[] keys = sct.keys();
	Iterator<Object> it = sct.valueIterator();
	while (it.hasNext()) {
	    arr.add(it.next());
	}
	return arr;
    }