Röda, 28 bytes

 (),.025^^cdfhnnnopprstuu{|}

Note the space at the beginning. No rounding, but it uses floating point numbers so precision is limited.

Perl, 42 bytes

There are 41 bytes of code and -p flag (no other flags).

/"/4~~r..rso4r<_$4va=eg1de|i/h0-&$c={}l+"

The result isn't rounded (or rather rounded up to the same point Perl would have round up by doing $_ = (sqrt $_) * ($_ ** 2)).

MATL, 12 bytes

'Un&0P'/^:+1

No rounding; uses floating point.

EDIT Sorry everyone, there was a mistake. Former O should be 0. Corrected now. (I would downvote myself for this if I could).

Octave, 43 bytes

$'()*+,-/23579:[]aelnouv'*,-23:[]lu',-23]',

This is a script that requires input from the command line (it's not a function). It's floating point accuracy (so no rounding).

Swift - 64 bytes

prot Fdnufi;nooitamunc xetgru(->atl)Ior:n{tFn pg,F(ao.o25t)(w)l}

No rounding, and displays a .0 even if the result is an integer.

Mathematica, 131 bytes, non-competing?, cracked

This has been cracked by @lanlock4! However, I still have internet points to bestow on someone who finds the original solution, where all the characters are actually needed....

f[y_]:=With[{x=@@@@@@#####^^&&&(((()))){{}}111111,,+-/y},Print[#,".",IntegerString[Round@#2,10,3]]&@@QuotientRemainder[1000x,1000]]

This is intended as a puzzle. Although you may use the above characters however you want, I certainly intend for the answer to follow the form

f[y_]:=With[{x=
    @@@@@@#####^^&&&(((()))){{}}111111,,+-/y
},Print[#,".",IntegerString[Round@#2,10,3]]&@@QuotientRemainder[1000x,1000]]

where the first and third lines are just a wrapper to make the rounding and display legal (it writes every output to exactly three decimal places, rounded), and the second line is the scrambled version of the guts of the code. Sample outputs:

6 -> 88.182
9 -> 243.000
9999 -> 9997500187.497

(Mathematica is non-free software, but there is a Wolfram sandbox where it is possible to test modest amounts of code. For example, cutting and pasting the code

f[y_]:=With[{x=
    y^2.5
},Print[#,".",IntegerString[Round@#2,10,3]]&@@QuotientRemainder[1000x,1000]]

defines a function, which you can subsequently call like f@6 or f[9], that does the same thing as the unscrambled version of the code above. So does this really have to be non-competing?)

Haskell, 16 bytes (Cracked by @nimi)

()*...25=eglopxx

No particular rounding

R, 28 bytes (Cracked by @Flounderer)

funny(p1)-tio(^*^)/pc(2)<p2;

Standard R floating-point accuracy.

C#, 172 bytes

       (((((())))))***,,,,......1225;;;;;;<====>CFLMMMMMPPPRSSSSSWaaaaaaabbbbcccddddddeeeeeeeeeeegghiiiiiiiillllllmmnnnnnnnooooooooqqqqrrrssssssssstttttttttuuuuuuuvvwyy{{}}

This code is a full program.

There are seven space characters at the start.

The input is read form STDIN and printed to STDOUT. The result is in double, no rounding done.

Inform 7, 71 bytes

""()**-..:[]
                 RT
aaaabeeeffilmmnnnnnooooooqrrrrrssstuuy

The code includes 17 spaces and 2 new lines. This is a full Infrom 7 program defining a function that prints the result with a precision of 5 decimal places.

OCaml, 13 bytes (Cracked by @Dada)

2*fn-5f>f*u .

No rounding (within IEEE 754 scope).

C, 50 bytes

%(())   ,-12225;>\\aaabbdddeeefffllnoooprrttuuuuw{

Uses standard IEEE754 rounding.

JavaScript (ES7), 20 bytes (Cracked by @IlmariKaronen)

****..22255666=>____

Standard JavaScript precision.

Python 2, 60 Bytes (Cracked by @notjagan)

 3n0)4  5)594p3(p5*5i9t4542)0/*((8(t.84- 90945 u)i*48/95n8r8

No rounding involved. Accurate up to 10 decimal digits.

Python 3.6 - 15 bytes (Cracked by Kritixi Lithos)

axx 2*d:b.*5mal

Standard rounding precision of Python

C++, 100 bytes (Cracked by @fergusq)

#.leiha2dm"
tuchn"crmueie<linaatt#dso
fameng pcae sli;t>dt nnsiuno;s mnpti;ouic(<){n(a;>w<n>n)co.,5}

Standard C++ rounding precision

Python 2, 44 Bytes (Cracked by @fəˈnɛtɪk)

np5w***i0(0(0r0n0t+iarn00p0)_(0tu00i50.0)) t

Has accuracy up to 10 decimal digits (I think). No rounding involved and there is a space involved.

Excel VBA, 59 bytes

?(())*..//11124AAAAFPSW[[]]^acceehiiiiklnnnnoooppqrrstttttu

No particular rounding.
Uses the Immediate Window.

Scala, 19 bytes (Cracked by @math_junkie)

)>,/2(=addd.hmoptw5

This is a function of type Int=>Double.

05AB1E, 4 bytes (Cracked by @Mr. Xcoder)

Must be really easy to crack, but I'll still post it here

n*t¹

Normal rounding

C, 60 bytes (Cracked by @Dave)

1(root, flat*fat bern**lotr);pw(f{bus(--q.b4/q0*1-2)})(b>1)b

Standard C float accuracy.

Javascript, 123 bytes, Cracked by notjagan

 """"""((((((((()))))))))********,--.....//2;;======>>Seeeeeeegggggggggggghhhhhhhhhhhilllllnnnnnnnnnnorrrsstttttttttttttu{}

This code is a full function

There is one space character at the very start of the list of characters

The rounding of this answer is the floating point precision for Javascript, accuracy is within 10^-6 for every answer.

Got shorter because the precision didn't need to be maintained quite as high as I thought it did.

I had realized that it would be much easier to solve than I initially had made it but it was already there :P

Initial code:

g=t=>t-(t*t-n)/("le".length*t);e=h=>{n=h*h*h*h*h,s=2**(n.toString("ng".length).length/"th".length);return g(g(g(g(g(s)))))}

Newtons method, applied 5 times from the closest power of 2

RProgN 2, 6 Bytes

š2]^+\

No rounding, displays many decimal places. Does not display any for an integer solution.

Haskell, 64 bytes

$$$$$$(((((())))))**,...0<<<>>>[]cccccdddeffiiiiilloopppprrsstuu

Standard Haskell floating point operations.

R, 19 bytes (Cracked by @Steadybox)

mensana(4*5*c(.1)):

Standard rounding

R, 33 bytes

(rofl(17)^coins(2*e)/pisan(10))--

Python 3.6 - 52 bytes (Cracked by @xnor)

f=lambda x:x**125*77*8+8/5/((('aafoort.hipie.xml')))

Standard Python rounding

C#, 112 bytes (cracked by Emigna)

     ((((())))),.....25;;;=CCLMMPPPRSWaaaaaaabbbccdddeeeeeeeeghiiiiiillllmnnnnnooooooorrrsssssssstttttuuvvwy{{}}

no rounding done

using System;
class P
{
    static void Main()
    {
        var b=double.Parse(Console.ReadLine());
        Console.Write(Math.Pow(b,2.5));
    }
}

Octave, 30 bytes

(((((())))))**++/:@eeeiiijmsu~

A bit simpler than my first one. Shouldn't be too hard, but it's hopefully a fun puzzle.

Python 2, 39 bytes (cracked by @Mr. Xcoder)

q=a(lxt)mh*mprf.hr
ax tttaixxmb :m*asod

Standard Python float rounding.

Octave, 42 bytes

((((()))))+,,,-//01111111@[]^mnooorrssst~~

No rounding. Floating point accuracy.