The values of the calculated observables are cached. Their value is calculated only initially and whenever the dependence changes. This way you can access this calculated value again and again and always get the cached value.
Based on your comments, it looks like you want to create computed observables based on specific arguments. A couple of considerations with this technique:
Relationships for one element are performed within the calculated observed tracking dependencies. This means that if you want to use your filter only in your user interface, you can avoid creating a computed observable and just call the filter function directly. Whenever a dependency changes, your bindings fire and the function starts again. This would not be the best solution if you also want to interact programmatically with the filtered data. Here is an example: http://jsfiddle.net/rniemeyer/QSgPz/
If you intend to use this concept often, you can even extend the observed arrays to call the filter directly from the observed array, for example: http://jsfiddle.net/rniemeyer/VhCVc/
Alternatively, if you have a function that returns a calculated value, then you want to make sure that you call it only once for each calculated filter that you need. You would not want to call it from the binding, where it will be recreated every time the binding is updated (unless you have a custom binding that handled it correctly in init). Here is an example: http://jsfiddle.net/rniemeyer/JrHnT/ . Again, you can expand the observed arrays to be able to create calculated ones for you if you use it often.
So, if you use this only from bindings, you can skip the calculated one and just use the function, since the binding uses its own computed observable. If you need to interact with it with your view model, then you probably want to create filters there.