code guessing, round #94 (completed)

fn isqrt(num: f32) -> f32{
  let bnum: u32 = num.to_bits() >> 1;
  let mnum: u32 = 1597463007;
  let rnum: u32 = mnum.wrapping_sub(bnum);
  let mut fnum: f32 = f32::from_bits(rnum);
  for _ in 0..3 {
    fnum *= 1.5 - (0.5 *  num  * fnum.powf(2.0));
  }
  return fnum;
}

return function(x) return x^-0.5 end

#!/usr/bin/dc -f

Fk1?v/p

Entry = (
  (
    ¤ ^ 1
    do(dip(×100)
      ⊂⊙^
      ddd(-1)
    | ggg(>0)
    )
    dgg◌
  )!(byback(dipsubonmulfloobel %))
  floby√unjoi      # evil floating point bit level hacking
  (base 10) for(sub˙*|×2|backward ⊂@.un⋕) # what the fuck?
  bot
  ⍢(dddunjoin
    ⊃(mulonrow,>⊂ran10gi|backjoi⊙⋅⋅(˜⊂0)|gdi) # gFdi tbh
    (keebelo ≡,1(>0⬚0⊣ keebyne 0^fill0-)
     forlas (-1 length)
     ⊃(⬚0subtradgi|joimul2 gdgi |˜⊂+@0⋅⊙⋅⋅∘)
     ∩(by parbox byeq 0^
       drotry (negalengun□⊣)0)
    )!(⬚0 add ⊂0⊃ (floodiv|◿) 10)
  |> 0lenggggi
  )
  &pggdp
)
Entry 21 37    # doesn't work
Entry 0.5 1024 # zombocom

#include <math.h>


double _sqrt(double x)
{
    double start = 0.0;
    double end = x;
    double mid;
    const double THRESHOLD = 1e-7;
    const int _ITER_LIMIT = 20;
    for(int i = 0; i < _ITER_LIMIT; i++) {
        mid = (start + end) / 2.0;
        if(fabs(mid * mid - x) < THRESHOLD) return mid;

        if(mid * mid > x) {
            end = mid;
        } else {
            start = mid;
        }
    }
    return mid;
}


double xa0c8a621(double x)
{
    return 1.0 / _sqrt(x);
}

import keras
import math
import numpy as np

# create a dataset
data = np.arange(0.001, 100, 0.00025)

np.random.shuffle(data)

# take a sample for testing purposes
split_data = np.array_split(data, 4)

x_train = np.concatenate((split_data[0], split_data[1], split_data[2]))
x_test = split_data[3]

split_data = None # wipe my temp variable

y_train = np.reciprocal(np.sqrt(x_train))
y_test = np.reciprocal(np.sqrt(x_test))

# set up a model / topology or whatever
model = keras.models.Sequential([
  keras.layers.Input(shape=(1,)),
  keras.layers.Dense(32, activation='relu'),
  keras.layers.Dense(16, activation='relu'),
  keras.layers.Dense(16, activation='relu'),
  keras.layers.Dense(1, activation='exponential')
])


# define a loss function
loss_fn = keras.losses.MeanSquaredLogarithmicError()

model.dropout = keras.layers.Dropout(0.0)

# compile the model, with the loss function
model.compile(optimizer='adam',
              loss=loss_fn,
              metrics=['mean_absolute_percentage_error'],
              auto_scale_loss=True)

# adjust the model to minimise loss
model.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=3)


# evaluate the model's performance
# for the purposes of this, I think 1 colour channel is fine
model.evaluate(x_test,  y_test, verbose=2)

while True: # bad bad bad error management, but good enough. Don't want it to hard crash after spending ages training.
  try:
    value = float(input("Enter test value: ").strip())
    prediction = model.predict(np.reshape(value, (1)))
    print("1 / sqrt({0}) ≈ {1}".format(value, prediction))
  except KeyboardInterrupt:
    break # (effectively just exit, but without importing sys)
  except:
    print("Invalid value! Please retry")

( Code by olus2000 )


: rsqrtss ( F: r1 -- r2 )
  fsqrt 1e fswap f/ ;