perlin noise terrain is spikey

I made custom perlin noise for fun however the terrain is very spiky from it rather than smooth rolling mountains.

This code is messy as i was experimenting.

 public class TestScript : MonoBehaviour {
 
     public Terrain myTerrain;
     float persistence = 0;
     int numberOfOctaves = 0;
     float frequency = 0;
     float amplitude = 0;
     // Use this for initialization
     void Start () {
 
         myTerrain = GetComponent<Terrain> ();
         float[,] heightMap = new float[myTerrain.terrainData.heightmapWidth, myTerrain.terrainData.heightmapHeight];
         for (int i = 0; i < myTerrain.terrainData.heightmapWidth; i++) {
             for(int j = 0; j < myTerrain.terrainData.heightmapHeight; j++){
                 heightMap[i,j] = setUpPerlinNoiseAndRun(i,j,1,1,0.5f,6);
             }
         }
         myTerrain.terrainData.SetHeights (0, 0, heightMap);
     }
     
     // Update is called once per frame
     void Update () {
 
     }
 
     public float setUpPerlinNoiseAndRun(float x, float y, float frequency, float amplitude, float persistence, int octave){
         this.frequency = frequency;
         this.amplitude = amplitude;
         this.persistence = persistence;
         this.numberOfOctaves = octave;
         
         return perlinNoise (x, y);
     }
 
     private float generateRandomNumber(float x, float y){
         int seed = (int)x + (int)y * 57;
         seed = (seed << 13) ^ seed;
         return (float)(1.0 -(( seed *( seed * seed * 15371 + 789221) + 1376312589) & 0x7FFFFFFF) / 1073741824.0);
     }
 
     private float cosineInterpolate(float a, float b, float x){
         float angle = x * Mathf.PI;
         float prc = (1 - Mathf.Cos(angle)) * 0.5f;
 
         return a * (1 - prc) + b * prc;
     }
 
     private float linearInterpolation(float a, float b, float x){
         return a * (1 - x) + b * x;
     }
 
     private float smoothNoise(float x, float y){
         float corners = (generateRandomNumber (x - 1, y - 1) + this.generateRandomNumber (x + 1, y - 1) + this.generateRandomNumber (x + 1, y + 1) + this.generateRandomNumber (x - 1, y + 1)) / 16;
         float sides = (generateRandomNumber (x - 1, y) + this.generateRandomNumber (x, y - 1) + this.generateRandomNumber (x + 1, y) + this.generateRandomNumber (x, y + 1)) / 8;
         float center = generateRandomNumber (x, y) / 4;
 
         return corners + sides + center;
     }
     private float interpolateNoise(float x, float y){
 
         int intX = (int)x;
         float fractionalX = x - intX;
 
         int intY = (int)y;
         float fractionalY = y - intY;
 
         float v1 = smoothNoise (intX, intY);
         float v2 = smoothNoise (intX + 1, intY);
         float v3 = smoothNoise (intX, intY + 1);
         float v4 = smoothNoise (intX + 1, intY + 1);
 
         float i1 = cosineInterpolate (v1, v2, fractionalX);
         float i2 = cosineInterpolate (v3, v4, fractionalX);
 
         return cosineInterpolate (i1, i2, fractionalY);
     }
 
     private float perlinNoise(float x, float y){
 
         float total = 0;
         float p = persistence;
         int n = numberOfOctaves - 1;
 
         for (int i = 0; i < n; i++) {
             frequency = Mathf.Pow(2, i);
             amplitude = Mathf.Pow(p, i);
 
             total = total + interpolateNoise(x * frequency, y * frequency) * amplitude;
         }
 
         return total;
     }
 }