View source for User:Wormbo/Random useful code snippets

On this page I will post various code snippets that are too useful to keep them to myself. Some of these probably deserve their own article pages with background information, and maybe I'll create them at some point.

==Linear search one-liner==
The most simple way to search for a value in an array is [[wp:linear search|linear search]]. The following implementation is (almost) a one-liner that works on all arrays, sorted or not.
<uscript>
local int i;

i = A.Length;
do {} until (--i < 0 || A[i] == Value);
</uscript>
Success is indicated by <code>i >= 0</code>, failure by <code>i == -1</code> or <code>i == INDEX_NONE</code> in UE3.

If the array is sorted and has more than just a few elements, you should consider using binary search instead.

==Binary Search==
The following very simply piece of code implements the [[wp:binary search algorithm|binary search algorithm]] with deferred detection of equality, looking for ''Value'' in array ''A''. If ''Value'' isn't in ''A'', the code returns the index where ''Value'' would have to be inserted.
<uscript>
local int Low, High, Middle;

Low = 0;
High = A.Length;
while (Low < High) {
  Middle = (High + Low) / 2;
  if (A[Middle] < Value)
    Low = Middle + 1;
  else
    High = Middle;
}
</uscript>
As you can see, the advantage here is that each loop iteration only performs a single less-than comparison between the search value and an array element.

So, why would you combine the equality and greater-than comparisons and give up early abort? Quite simple: The equality comparison would fail most of the time anyway, so it doesn't actually give that much of an advantage, considering binary search only has an overall worst case time complexity of <code>O(log<sub>2</sub>n)</code>. And, well, you only need to implement a less-than comparison for custom data types as opposed to less-then and greater-than. Here "less than" could actually mean "greater than" if the array is sorted in descending order or anything else, as long as it is a [[wp:strict total order|strict total order]] on the possible values for the array's [[type]].

To figure out whether you found the value or not, an additional comparison is required:
<uscript>
if (Low < A.Length && A[Low] == Value)
  // found it
else
  // not found
</uscript>
You can assume that ''Low'' always is a valid insert index less than or equal to <code>A.Length</code>, so <code>A.Insert(Low, 1); A[Low] = Value;</code> (or <code>A.InsertItem(Low, Value);</code> in [[UE3]]) will always work correctly.

It is guaranteed that <code>Low < A.Length</code> implies <code>A[Low] >= Value</code> and <code>Low > 0</code> implies <code>A[Low-1] < Value</code>. That means if you want to remove all values less than ''Value'', you can simply do <code>A.Remove(0, Low)</code>. To remove all values greater than or equal to ''Value'', you use <code>A.Remove(Low, A.Length - Low)</code>.

To find the first index with a value greater than ''Value'', you just need a tiny modification:
<uscript>
local int Low, High, Middle;

Low = 0;
High = A.Length;
while (Low < High) {
  Middle = (High + Low) / 2;
  if (A[Middle] <= Value)
    Low = Middle + 1;
  else
    High = Middle;
}
</uscript>
This version can be used if you want to ensure that new instances of values considered as "equal" are inserted after all previous instances, whereas the other version of the algorithm finds an insert location before all other equal instances.

Again you can assume that ''Low'' always is a valid insert index less than or equal to <code>A.Length</code>. It is guaranteed that <code>Low < A.Length</code> implies <code>A[Low] > Value</code> and <code>Low > 0</code> implies <code>A[Low-1] <= Value</code>. That means if you want to remove all values less than or equal to ''Value'', you can simply do <code>A.Remove(0, Low)</code>. To remove all values greater than ''Value'', you use <code>A.Remove(Low, A.Length - Low)</code>. Note how the "or equal to" now is part of the other side of the array.

==Finding common string prefix==
For [[wp:incremental encoding|incremental encoding]] you need to find the common prefix of two strings. Usually you'd do that by comparing corresponding characters of both strings, starting from the front, but UnrealScript is quite inefficient for that. I found that, at least in UT2004, you could use the StrCmp() function to compare string prefixes. Now you only need to find the largest prefix length at which both string starts are still equal. Technically this is a searching operation and the easy way to do it would be a linear search. But if there's a reasonably good chance the strings have large common parts, you could even abuse binary search for this. The following code snippet finds the largest common prefix length of strings A and B:
<uscript>
local int Low, High, Middle;

Low = 0;
High = Min(Len(A), Len(B));
while (Low < High) {
  Middle = (High + Low) / 2;
  if (StrCmp(A, B, Middle) == 0)
    Low = Middle + 1;
  else
    High = Middle;
}
</uscript>
Looks scary? I hope so. ;-)

==Collapsing whitespace==
This code will remove leading and trailing whitespace from a string and simultaneously collapse any sequence of space and tab characters into a single space:
<uscript>
static final function string CollapseAndTrimWhitespace(string S)
{
  S = " " $ Repl(S, Chr(9), " ") $ " "; // replace tabs with spaces and enclose in space chars for collapsing
  while (InStr(S, "  ") != -1) { // need whitespace collapsing?
    S = Repl(S, "  ", " "); // collapse two adjacent spaces to a single space
  }
  return Mid(S, 1, Len(S) - 2); // remove enclosing space chars
}
</uscript>
I know, InStr() and Repl() are really linear time operations, causing the algorithm to be something like O(n*logn). But as usual UnrealScript's slowness adds a high constant part to them, essentially making them constant time for reasonably short strings (up to a few hundred characters), and the whole function sort-of O(logn).

==Integer modulo operator==
The [[wp:modulo operation|modulo]] operator <code>%</code> in UnrealScript is only defined for float operands, which can cause bad rounding errors if you use it with large int values. The following code [[wp:Operator overloading|overloads]] the modulo operator for int values:
<uscript>
static final operator(18) int % (int A, int B)
{
  return A - (A / B) * B;
}
</uscript>
This has similar semantics as the float modulo operator, i.e. it may return negative values if you pass in negative operands. Note that (A/B)*B is not the same as A due to integer division dropping any potential remainder.

==ArcTan function==
Need the standard one-parameter version of the [[wp:arctan|atan]] function and your version of the game only provides the [[wp:atan2|two-parameter version]]? Try this one:
<uscript>
static final function float ArcTan(float A)
{
  return ATan(1, A);
}
</uscript>

==Vector magic==
===Distance of point from line===
This one might be useful e.g. for determining by how much a shot missed a target:
<uscript>
dist = VSize(Normal(ShotDir) cross (TargetLocation - ShotStart));
</uscript>
This formula relies on the fact that the length of the [[wp:cross product|cross product]] is the product of the two vector lengths times the [[wp:sine|sine]] of the angle between them. Note that the resulting vector of the cross product itself is actually orthogonal to both the shot direction and the vector pointing from the shot start to the target direction.

===In front or behind?===
You'd probably use this one in combination with the above to figure out whether the target was actually shot at:
<uscript>
bInFront = (ShotDir dot (TargetLocation - ShotStart)) > 0;
</uscript>
If you normalize both vectors, the [[wp:dot product|dot product]] actually gives you the [[wp:cosine|cosine]] of the angle between them. If you don't, the cosine is multiplied by the product of the two vectors' lengths. Either way, the cosine is positive for angles smaller than 90° and negative for angles greater than 90°.

===Closest point on a line===
If you want to know the point on a line that is closest to some other point (usually) not on the line, you need to project the other point onto the line:
<uscript>
ClosestPoint = ShotStart + Normal(ShotDir) * (Normal(ShotDir) dot (TargetLocation - ShotStart));
</uscript>
You can obviously skip normalization if the shot direction already is a [[wp:unit vector|unit vector]].

{{DEFAULTSORT:{{SUBPAGENAME}}}}
[[Category:UnrealScript utils]]