How secure is this logarithmic encryption algorithm? How secure would the following logarithmic encryption algorithm be when tested under the same conditions as high end encryption algorithms (AES, RSA etc...).

Note: For smaller text the text will be padded to form a minimum length of 1024 bits.

For encryption: 
1.  Generate random numbers as same length as the message.  R = [5, 13] 
2.  Turn message characters into ordinal numbers.  M = [97, 98] 
3.  Encryption algorithm is as follows: M^x = R; to solve this: x = log(R)/log(M) 

For decryption: 
1.  To find the original ordinal number again: M = x_sqrt(R, x); x_sqrt is to find the nth_root of a number, where R is the the radicand and x is index. 

Example: 
R = [13] 
M = [98] 

Encryption: 
M^x = R 
: 98^x = 13 
: x = log(13) / log(98) 
: x = 0.559425856 

Decryption: 
M = x_sqrt(R, x) 
: M = x_sqrt(13, 0.559425856) 
: M = 98
I'll assume R is secret, and is the key; and the ciphertext is given as a list of values x in decimal, as in the example given x = 0.559425856. 

This is totally insecure: even without knowledge of R, it is trivial to reduce candidate plaintext letters to almost nothing, just by knowing the corresponding x. e.g. if we assume R is an integer in range [2..127], and x = 0.559425856, the only pair (R,M) possible is (13,98). That can be seen by tabulating x by increasing values as follows

 x               R        M
0.557913767     10       62
0.558189871     13       99
0.558248536     14      113
0.558830625      9       51
0.558890092     11       73
0.559030886     15      127
0.559300193     14      112
0.559329667     12       85
0.559425856     13       98
0.559944654     15      126
0.559957234      8       41
0.560120590     10       61
0.560365305     14      111
0.560680089     13       97
0.560692653     11       72
0.560823605     12       84
0.560868731     15      125
0.561444177     14      110


The problem can NOT be fully fixed by giving just enough decimals of x to allows decryption (here, x = 0.559 would do if we round to the nearest), for that still allows to reduce the possibilities in the plaintext a lot.

A lesser problem is that if the plaintext gets known, it is trivial to find R. Hence R can not be reused for different plaintexts. Hence this is not a cipher by the modern definition of that, which requires that there's a key reusable for several messages. That also makes use of the system impractical, as the OTP is; but at least that one is secure.

Also, the ciphertext is larger than the plaintext; another problem that the OTP does not have.