Just to get some definitions out of the way:
View Functions -- "Functions can be declared view in which case they promise not to modify the state."
Pure Functions -- "Functions can be declared pure in which case they promise not to read from or modify the state."
The important part here is that these functions types will not modify the state. Because they don't modify the state, there is no reason to run calls to these functions on the blockchain (for example, from web3).
what if the node simply does the wrong computation
With any innocent node, your code will be run as if it were run on the chain, but just by the one node (instead of broadcasting as a transaction, it will run locally only).
It is somewhat possible there would be a malicious node that returns incorrect answers, but at that point, the question would be why you are asking that node for information in the first place. If you are hosting the node yourself, calls to view/pure functions will be run locally (on your own node) -- They will be correct as far as your node is synced up with the rest of the network. If you are using a service (like infura), your calls will be run against their node, and you are assuming they are acting honestly.
How does this work with calls from solidity? In those cases is the computation guaranteed to run the code in the pure function correctly?
If I understand the question, you are asking about function calls from within an actual transaction. In this case, the calls are being run "on the chain". All this means is that each node participating in the mining process is running all the transactions in order to find a block. Any attempt to change data (e.g. return incorrect answers from view/pure functions) would invalidate the block, and the network wouldn't accept it as a valid block. So you can trust that the transactions are being run correctly -- any tampering would only hurt the miner because they would miss out on any rewards they would have claimed from mining a valid block.
One side I note I thought I should mention is that the difference between calling
view functions from web3 and calling them in actual transactions is that the state of the chain will have changed based one the transactions appearing above your transaction in a given block. These may or may not affect the result given on the chain.
This is not an issue for
pure functions because they do not even read the state in order to execute.