Returns a new Damerau-Levenshtein distance instance with compare target string

@see Damerau
@param baseTarget
@param compareTarget
@return
327919
@SuppressWarnings("unchecked")
	public static <T extends Levenshtein> T damerau(String baseTarget, String compareTarget) {
		return (T) new Damerau(baseTarget).update(compareTarget);
	}
956473
public BeadledomWebTarget buildTarget(String baseUrl) {
    BeadledomClient beadledomClient = build();
    return beadledomClient.target(baseUrl);
  }
116783
public <T> JdbcMapperBuilder<T> newBuilder(final Class<T> target) {
		return newBuilder((Type)target);
	}
360949
@InterfaceAudience.Public
    public void setCreateTarget(boolean createTarget) {
        properties.put(ReplicationField.CREATE_TARGET, createTarget);
        replicationInternal.setCreateTarget(createTarget);
    }
91504
public <T> JdbcMapperBuilder<T> newBuilder(final Type target) {
		ClassMeta<T> classMeta = getClassMeta(target);
		return newBuilder(classMeta);
	}
717607
@SuppressWarnings({ "cast", "unchecked" })
  public static <O extends SpatialComparable> KNNQuery<O> getKNNQuery(AbstractRStarTree<?, ?, ?> tree, SpatialDistanceQuery<O> distanceQuery, Object... hints) {
    // Can we support this distance function - spatial distances only!
    SpatialPrimitiveDistanceFunction<? super O> df = distanceQuery.getDistanceFunction();
    if(EuclideanDistanceFunction.STATIC.equals(df)) {
      return (KNNQuery<O>) new EuclideanRStarTreeKNNQuery<>(tree, (Relation<NumberVector>) distanceQuery.getRelation());
    }
    return new RStarTreeKNNQuery<>(tree, distanceQuery.getRelation(), df);
  }
1247374
private static boolean isMatching(Method base, Method compare) {

		// if names and argument types match ... then this are the same method
		if (base.getName().equals(compare.getName()) &&
		    base.getParameterCount() == compare.getParameterCount()) {

			Class<?>[] typeBase = base.getParameterTypes();
			Class<?>[] typeCompare = compare.getParameterTypes();

			for (int index = 0; index < typeBase.length; index++) {
				Class clazzBase = typeBase[index];
				Class clazzCompare = typeCompare[index];
				if (!clazzBase.equals(clazzCompare)) {
					return false;
				}
			}

			return true;
		}

		return false;
	}
392655
public static <T extends Levenshtein> T QGram(String baseTarget, String compareTarget) {
		return QGram(baseTarget, compareTarget, null);
	}
520773
public int compare(String string2, int maxDistance) {
        switch (algorithm) {
            case Damerau: return DamerauLevenshteinDistance(string2, maxDistance);
        }
        throw new IllegalArgumentException("unknown DistanceAlgorithm");
    }
25648
public static ResourceBundle getResourceBundle(String baseName,
            Locale targetLocale) {
        Locale.setDefault(targetLocale);
        return ResourceBundle.getBundle(baseName);
    }
410850
public WebTarget appendPathAndQueryParameters(final WebTarget webTarget) {
    ArgumentChecker.notNull(webTarget, "webTarget");
    WebTarget resultTarget = webTarget;
    resultTarget = resultTarget.path(DATASETS_RELATIVE_URL);
    resultTarget = resultTarget.path(_quandlCode + EXTENSION);
    resultTarget = resultTarget.queryParam(EXCLUDE_DATA_PARAM, INFINITE_FUTURE);
    return resultTarget;
  }
268280
private void checkTargetDistance(double dist)
    {
        if (distAttack.includes(dist))
        {
            if (checker.canAttack())
            {
                state = AttackState.ATTACKING;
            }
        }
        else if (tick.elapsed(attackPause))
        {
            for (final AttackerListener listener : listeners)
            {
                listener.notifyReachingTarget(target);
            }
        }
    }
7066
public WebTarget appendPathAndQueryParameters(final WebTarget webTarget) {
    ArgumentChecker.notNull(webTarget, "webTarget");
    WebTarget resultTarget = webTarget;
    resultTarget = resultTarget.path(MULTI_SET_NAME + EXTENSION);
    resultTarget = resultTarget.queryParam(COLUMNS_PARAM, buildCodeList(_quandlCodes));
    // This is a hack that stops Quandl from returning all the data as part of the query
    resultTarget = resultTarget.queryParam(EXCLUDE_DATA_PARAM, INFINITE_FUTURE);
    return resultTarget;
  }
645938
public static <T extends Key <T>> GroupMatcher <T> groupStartsWith (final String compareTo)
  {
    return new GroupMatcher <> (compareTo, StringOperatorName.STARTS_WITH);
  }
144717
@Override
    public DataByteOutput<T> target(final T target) {
        return (DataByteOutput<T>) super.target(target);
    }
195029
private PriorityQueue<HeapItem> search(final double[] target, double maxDistance, final int k) {
		PriorityQueue<HeapItem> heap = new PriorityQueue<HeapItem>();
		if (root == null) {
			return heap;
		}

		double tau = maxDistance;
		final FastQueue<Node> nodes = new FastQueue<Node>(20, Node.class, false);
		nodes.add(root);

		while (nodes.size() > 0) {
			final Node node = nodes.removeTail();
			final double dist = distance(items[node.index], target);

			if (dist <= tau) {
				if (heap.size() == k) {
					heap.poll();
				}
				heap.add(new HeapItem(node.index, dist));
				if (heap.size() == k) {
					tau = heap.element().dist;
				}
			}

			if (node.left != null && dist - tau <= node.threshold) {
				nodes.add(node.left);
			}

			if (node.right != null && dist + tau >= node.threshold) {
				nodes.add(node.right);
			}
		}

		return heap;
	}
486067
public function getAttackNumber(Distance $targetDistance, Size $targetSize): AttackNumber
    {
        return $this->createBaseAttackNumber()->add($this->getAttackNumberModifier($targetDistance, $targetSize));
    }