^ It's your second interpretation.
As ShaiHulud said, what you want is an utility class, in other words, a class which has nothing more than static methods which you can call from anywhere directly.
Then to actually use them, you can check this:
https://wiki.beyondunreal.com/Legacy:Static_Function
That is, as long they're just really "helper functions" and nothing more than that, and thus only depend exclusively on the given arguments when calling the function, and do not depend on anything else (other than perhaps default values from a configuration, at most).
You did however link to a page which also has operators, and operators are a different story altogether.
Operators must be declared in the same class you're going to use them or a parent class, this is why Object (the parent of all classes) has all the operators declared in it, so it can be used by itself and any child classes.
So this would mean that if you want to define your own operators or use some from that page, you would need to copy & paste them into the classes which are not related to each other (a class extending from Projectile and another extending from Pawn for example, one can never be a parent of the other).
This is because UnrealScript, like most OO languages out there, do not allow multiple inheritance, and it's not the only language with this kind of problems.
For these cases, languages like PHP (for example) created the concept of "traits".
Traits in PHP are just special classes in which you can define both methods and properties, and if you have a class to "use" a trait, what will actually happen is that the code of the trait is copy & pasted into that class.
In other words, is very similar to an "include" in C or C++ for example, but it's a special kind of class.
While in UnrealScript there's no such thing, if you're up to it, you (or someone else?) can perhaps build an external preprocessor (probably in another language) which is able to add a similar functionality, perhaps through a "#include" directive in the code, where by defining something like:
the preprocessor would include the file you're referencing into the actual targeted uc file before compiling it.
This way, should you make a change (like a bug fix) or want to add something new across these classes, it would be easy to do, as you would only need to change in a single file, as the classes which used it would have it automatically copy & pasted right before being compiled.
But only if someone builds such a tool, of course.