@neaps/tide-predictor 0.0.4

package/src/constituents/__tests__/compound-constituent.js

@@ -0,0 +1,44 @@
+import compoundConstituent from '../compound-constituent'
+import Constituent from '../constituent'
+import astro from '../../astronomy'
+
+const sampleTime = new Date()
+sampleTime.setFullYear(2019)
+sampleTime.setMonth(9)
+sampleTime.setDate(4)
+sampleTime.setHours(10)
+sampleTime.setMinutes(15)
+sampleTime.setSeconds(40)
+sampleTime.setMilliseconds(10)
+
+const testAstro = astro(sampleTime)
+
+// This is a made-up doodson number for a test coefficient
+const testConstituentA = new Constituent('testa', [1, 1, -1, 0, 0, 0, 1])
+const testConstituentB = new Constituent('testb', [0, 1, -1, 0, 0, 0, 1])
+
+const compoundTest = compoundConstituent('test compound', [
+  { constituent: testConstituentA, factor: 1 },
+  { constituent: testConstituentB, factor: -1 }
+])
+describe('compund constituent', () => {
+  test('it calculates compound coefficients', () => {
+    expect(compoundTest.coefficients).toEqual([1, 0, 0, 0, 0, 0, 0])
+  })
+
+  test('it calculates speed', () => {
+    expect(compoundTest.speed(testAstro)).toBeCloseTo(14.4920521208, 4)
+  })
+
+  test('it calculates value', () => {
+    expect(compoundTest.value(testAstro)).toBeCloseTo(268.504355062, 4)
+  })
+
+  test('it returns u correctly', () => {
+    expect(compoundTest.u(testAstro)).toBe(0)
+  })
+
+  test('it returns f correctly', () => {
+    expect(compoundTest.f(testAstro)).toBe(1)
+  })
+})

package/src/constituents/__tests__/constituent.js

@@ -0,0 +1,65 @@
+import constituent, {
+  astronimicDoodsonNumber,
+  astronomicSpeed,
+  astronomicValues
+} from '../constituent'
+import astro from '../../astronomy'
+
+const sampleTime = new Date()
+sampleTime.setFullYear(2019)
+sampleTime.setMonth(9)
+sampleTime.setDate(4)
+sampleTime.setHours(10)
+sampleTime.setMinutes(15)
+sampleTime.setSeconds(40)
+sampleTime.setMilliseconds(10)
+
+const testAstro = astro(sampleTime)
+
+// This is a made-up doodson number for a test coefficient
+const testConstituent = constituent('test', [1, 1, -1, 0, 0, 0, 1])
+
+describe('constituent', () => {
+  test('it throws error if missing coefficients', () => {
+    let errorMessage = false
+    try {
+      const a = constituent('fail') // eslint-disable-line
+    } catch (error) {
+      errorMessage = error
+    }
+    expect(errorMessage.message).toBe(
+      'Coefficient must be defined for a constituent'
+    )
+  })
+
+  test('it fetches astronimic Doodson Number values', () => {
+    const values = astronimicDoodsonNumber(testAstro)
+    expect(values[0].value).toBe(testAstro['T+h-s'].value)
+  })
+
+  test('it fetches astronimic speed', () => {
+    const values = astronomicSpeed(testAstro)
+    expect(values[0]).toBe(testAstro['T+h-s'].speed)
+  })
+
+  test('it fetches astronimic values', () => {
+    const values = astronomicValues(testAstro)
+    expect(values[0]).toBe(testAstro['T+h-s'].value)
+  })
+
+  test('it computes constituent value', () => {
+    expect(testConstituent.value(testAstro)).toBeCloseTo(423.916666657, 4)
+  })
+
+  test('it computes constituent speed', () => {
+    expect(testConstituent.speed(testAstro)).toBe(15)
+  })
+
+  test('it returns u correctly', () => {
+    expect(testConstituent.u(testAstro)).toBe(0)
+  })
+
+  test('it returns f correctly', () => {
+    expect(testConstituent.f(testAstro)).toBe(1)
+  })
+})

package/src/constituents/__tests__/index.js

@@ -0,0 +1,34 @@
+import constituents from '../index'
+import astro from '../../astronomy'
+
+const sampleTime = new Date()
+sampleTime.setFullYear(2019)
+sampleTime.setMonth(9)
+sampleTime.setDate(4)
+sampleTime.setHours(10)
+sampleTime.setMinutes(15)
+sampleTime.setSeconds(40)
+sampleTime.setMilliseconds(10)
+
+const testAstro = astro(sampleTime)
+
+describe('Base constituent definitions', () => {
+  test('it prepared constituent SA', () => {
+    expect(constituents.SA.value(testAstro)).toBeCloseTo(192.826398978, 4)
+  })
+
+  test('it prepared constituent SSA', () => {
+    expect(constituents.SSA.value(testAstro)).toBeCloseTo(385.652797955, 4)
+  })
+
+  test('it prepared constituent M2', () => {
+    expect(constituents.M2.value(testAstro)).toBeCloseTo(537.008710124, 4)
+    expect(constituents.M2.u(testAstro)).toBeCloseTo(-2.07725095711, 4)
+    expect(constituents.M2.f(testAstro)).toBeCloseTo(1.00853563237, 4)
+  })
+
+  test('has a correct lambda for M3', () => {
+    expect(constituents.M3.u(testAstro)).toBeCloseTo(-3.11587643567, 4)
+    expect(constituents.M3.f(testAstro)).toBeCloseTo(1.01283073119, 4)
+  })
+})

package/src/constituents/compound-constituent.js

@@ -0,0 +1,55 @@
+const compoundConstituentFactory = (name, members) => {
+  const coefficients = []
+  members.forEach(({ constituent, factor }) => {
+    constituent.coefficients.forEach((coefficient, index) => {
+      if (typeof coefficients[index] === 'undefined') {
+        coefficients[index] = 0
+      }
+      coefficients[index] += coefficient * factor
+    })
+  })
+
+  const compoundConstituent = {
+    name: name,
+
+    coefficients: coefficients,
+
+    speed: (astro) => {
+      let speed = 0
+      members.forEach(({ constituent, factor }) => {
+        speed += constituent.speed(astro) * factor
+      })
+      return speed
+    },
+
+    value: (astro) => {
+      let value = 0
+      members.forEach(({ constituent, factor }) => {
+        value += constituent.value(astro) * factor
+      })
+      return value
+    },
+
+    u: (astro) => {
+      let u = 0
+      members.forEach(({ constituent, factor }) => {
+        u += constituent.u(astro) * factor
+      })
+      return u
+    },
+
+    f: (astro) => {
+      const f = []
+      members.forEach(({ constituent, factor }) => {
+        f.push(Math.pow(constituent.f(astro), Math.abs(factor)))
+      })
+      return f.reduce((previous, value) => {
+        return previous * value
+      })
+    },
+  }
+
+  return Object.freeze(compoundConstituent)
+}
+
+export default compoundConstituentFactory

package/src/constituents/constituent.js

@@ -0,0 +1,74 @@
+import nodeCorrections from '../node-corrections/index'
+
+/**
+ * Computes the dot notation of two arrays
+ * @param {*} a
+ * @param {*} b
+ */
+const dotArray = (a, b) => {
+  const results = []
+  a.forEach((value, index) => {
+    results.push(value * b[index])
+  })
+  return results.reduce((total, value) => {
+    return total + value
+  })
+}
+
+const astronimicDoodsonNumber = (astro) => {
+  return [
+    astro['T+h-s'],
+    astro.s,
+    astro.h,
+    astro.p,
+    astro.N,
+    astro.pp,
+    astro['90'],
+  ]
+}
+
+const astronomicSpeed = (astro) => {
+  const results = []
+  astronimicDoodsonNumber(astro).forEach((number) => {
+    results.push(number.speed)
+  })
+  return results
+}
+
+const astronomicValues = (astro) => {
+  const results = []
+  astronimicDoodsonNumber(astro).forEach((number) => {
+    results.push(number.value)
+  })
+  return results
+}
+
+const constituentFactory = (name, coefficients, u, f) => {
+  if (!coefficients) {
+    throw new Error('Coefficient must be defined for a constituent')
+  }
+
+  const constituent = {
+    name: name,
+
+    coefficients: coefficients,
+
+    value: (astro) => {
+      return dotArray(coefficients, astronomicValues(astro))
+    },
+
+    speed(astro) {
+      return dotArray(coefficients, astronomicSpeed(astro))
+    },
+
+    u: typeof u !== 'undefined' ? u : nodeCorrections.uZero,
+
+    f: typeof f !== 'undefined' ? f : nodeCorrections.fUnity,
+  }
+
+  return Object.freeze(constituent)
+}
+
+export default constituentFactory
+
+export { astronimicDoodsonNumber, astronomicSpeed, astronomicValues }

package/src/constituents/index.js

@@ -0,0 +1,119 @@
+import constituent from './constituent'
+import compoundConstituent from './compound-constituent'
+import nc from '../node-corrections/index'
+
+const constituents = {}
+// Long Term
+constituents.Z0 = constituent('Z0', [0, 0, 0, 0, 0, 0, 0], nc.uZero, nc.fUnity)
+constituents.SA = constituent('Sa', [0, 0, 1, 0, 0, 0, 0], nc.uZero, nc.fUnity)
+constituents.SSA = constituent(
+  'Ssa',
+  [0, 0, 2, 0, 0, 0, 0],
+  nc.uZero,
+  nc.fUnity
+)
+constituents.MM = constituent('MM', [0, 1, 0, -1, 0, 0, 0], nc.uZero, nc.fMm)
+constituents.MF = constituent('MF', [0, 2, 0, 0, 0, 0, 0], nc.uMf, nc.fMf)
+// Diurnals
+constituents.Q1 = constituent('Q1', [1, -2, 0, 1, 0, 0, 1], nc.uO1, nc.fO1)
+constituents.O1 = constituent('O1', [1, -1, 0, 0, 0, 0, 1], nc.uO1, nc.fO1)
+constituents.K1 = constituent('K1', [1, 1, 0, 0, 0, 0, -1], nc.uK1, nc.fK1)
+constituents.J1 = constituent('J1', [1, 2, 0, -1, 0, 0, -1], nc.uJ1, nc.fJ1)
+constituents.M1 = constituent('M1', [1, 0, 0, 0, 0, 0, 1], nc.uM1, nc.fM1)
+constituents.P1 = constituent('P1', [1, 1, -2, 0, 0, 0, 1], nc.uZero, nc.fUnity)
+constituents.S1 = constituent('S1', [1, 1, -1, 0, 0, 0, 0], nc.uZero, nc.fUnity)
+constituents.OO1 = constituent('OO1', [1, 3, 0, 0, 0, 0, -1], nc.uOO1, nc.fOO1)
+// Semi diurnals
+constituents['2N2'] = constituent('2N2', [2, -2, 0, 2, 0, 0, 0], nc.uM2, nc.fM2)
+constituents.N2 = constituent('N2', [2, -1, 0, 1, 0, 0, 0], nc.uM2, nc.fM2)
+constituents.NU2 = constituent('NU2', [2, -1, 2, -1, 0, 0, 0], nc.uM2, nc.fM2)
+constituents.M2 = constituent('M2', [2, 0, 0, 0, 0, 0, 0], nc.uM2, nc.fM2)
+constituents.LAM2 = constituent('LAM2', [2, 1, -2, 1, 0, 0, 2], nc.uM2, nc.fM2)
+constituents.L2 = constituent('L2', [2, 1, 0, -1, 0, 0, 2], nc.uL2, nc.fL2)
+constituents.T2 = constituent('T2', [2, 2, -3, 0, 0, 1, 0], nc.uZero, nc.fUnity)
+constituents.S2 = constituent('S2', [2, 2, -2, 0, 0, 0, 0], nc.uZero, nc.fUnity)
+constituents.R2 = constituent(
+  'R2',
+  [2, 2, -1, 0, 0, -1, 2],
+  nc.uZero,
+  nc.fUnity
+)
+constituents.K2 = constituent('K2', [2, 2, 0, 0, 0, 0, 0], nc.uK2, nc.fK2)
+// Third diurnal
+constituents.M3 = constituent(
+  'M3',
+  [3, 0, 0, 0, 0, 0, 0],
+  (a) => {
+    return nc.uModd(a, 3)
+  },
+  (a) => {
+    return nc.fModd(a, 3)
+  }
+)
+// Compound
+constituents.MSF = compoundConstituent('MSF', [
+  { constituent: constituents.S2, factor: 1 },
+  { constituent: constituents.M2, factor: -1 },
+])
+
+// Diurnal
+constituents['2Q1'] = compoundConstituent('2Q1', [
+  { constituent: constituents.N2, factor: 1 },
+  { constituent: constituents.J1, factor: -1 },
+])
+constituents.RHO = compoundConstituent('RHO', [
+  { constituent: constituents.NU2, factor: 1 },
+  { constituent: constituents.K1, factor: -1 },
+])
+
+// Semi-Diurnal
+
+constituents.MU2 = compoundConstituent('MU2', [
+  { constituent: constituents.M2, factor: 2 },
+  { constituent: constituents.S2, factor: -1 },
+])
+constituents['2SM2'] = compoundConstituent('2SM2', [
+  { constituent: constituents.S2, factor: 2 },
+  { constituent: constituents.M2, factor: -1 },
+])
+
+// Third-Diurnal
+constituents['2MK3'] = compoundConstituent('2MK3', [
+  { constituent: constituents.M2, factor: 1 },
+  { constituent: constituents.O1, factor: 1 },
+])
+constituents.MK3 = compoundConstituent('MK3', [
+  { constituent: constituents.M2, factor: 1 },
+  { constituent: constituents.K1, factor: 1 },
+])
+
+// Quarter-Diurnal
+constituents.MN4 = compoundConstituent('MN4', [
+  { constituent: constituents.M2, factor: 1 },
+  { constituent: constituents.N2, factor: 1 },
+])
+constituents.M4 = compoundConstituent('M4', [
+  { constituent: constituents.M2, factor: 2 },
+])
+constituents.MS4 = compoundConstituent('MS4', [
+  { constituent: constituents.M2, factor: 1 },
+  { constituent: constituents.S2, factor: 1 },
+])
+constituents.S4 = compoundConstituent('S4', [
+  { constituent: constituents.S2, factor: 2 },
+])
+
+// Sixth-Diurnal
+constituents.M6 = compoundConstituent('M6', [
+  { constituent: constituents.M2, factor: 3 },
+])
+constituents.S6 = compoundConstituent('S6', [
+  { constituent: constituents.S2, factor: 3 },
+])
+
+// Eighth-Diurnals
+constituents.M8 = compoundConstituent('M8', [
+  { constituent: constituents.M2, factor: 4 },
+])
+
+export default constituents

package/src/harmonics/__tests__/index.js

@@ -0,0 +1,123 @@
+import harmonics, { getDate, getTimeline } from '../index'
+import mockHarmonicConstituents from '../../__mocks__/constituents'
+
+const startDate = new Date(1567346400 * 1000) // 2019-09-01
+const endDate = new Date(1569966078 * 1000) // 2019-10-01
+
+describe('harmonics', () => {
+  test('it checks constituents', () => {
+    let errorMessage = false
+
+    try {
+      harmonics({ harmonicConstituents: 'not array' })
+    } catch (error) {
+      errorMessage = error
+    }
+    expect(errorMessage.message).toBe('Harmonic constituents are not an array')
+
+    errorMessage = false
+
+    try {
+      harmonics({
+        harmonicConstituents: [
+          {
+            name: 'M2',
+            description: 'Principal lunar semidiurnal constituent',
+            amplitude: 1.61,
+            phase_GMT: 181.3,
+            phase_local: 309.4,
+            speed: 28.984104,
+          },
+          {
+            description: 'Principal solar semidiurnal constituent',
+            amplitude: 0.43,
+            phase_GMT: 180.1,
+            phase_local: 309.4,
+          },
+        ],
+      })
+    } catch (error) {
+      errorMessage = error
+    }
+    expect(errorMessage.message).toBe(
+      'Harmonic constituents must have a name property'
+    )
+
+    errorMessage = false
+
+    try {
+      harmonics({
+        harmonicConstituents: [
+          {
+            name: 'not a name',
+            description: 'Principal lunar semidiurnal constituent',
+            amplitude: 1.61,
+            phase_GMT: 181.3,
+            phase_local: 309.4,
+            speed: 28.984104,
+          },
+          {
+            name: 'M2',
+            description: 'Principal solar semidiurnal constituent',
+            amplitude: 0.43,
+            phase_GMT: 180.1,
+            phase_local: 309.4,
+          },
+        ],
+      })
+    } catch (error) {
+      errorMessage = error
+    }
+    expect(errorMessage.message).toBeFalsy()
+  })
+
+  test('it checks start and end times', () => {
+    const testHarmonics = harmonics({
+      harmonicConstituents: mockHarmonicConstituents,
+    })
+    let timeErrorMessage = false
+    try {
+      testHarmonics.setTimeSpan('lkjsdlf', 'sdfklj')
+    } catch (error) {
+      timeErrorMessage = error
+    }
+    expect(timeErrorMessage.message).toBe(
+      'Invalid date format, should be a Date object, or timestamp'
+    )
+
+    timeErrorMessage = false
+    try {
+      testHarmonics.setTimeSpan(startDate, startDate)
+    } catch (error) {
+      timeErrorMessage = error
+    }
+    expect(timeErrorMessage.message).toBe('Start time must be before end time')
+
+    timeErrorMessage = false
+    try {
+      testHarmonics.setTimeSpan(startDate, endDate)
+    } catch (error) {
+      timeErrorMessage = error
+    }
+    expect(timeErrorMessage.message).toBeFalsy()
+  })
+
+  test('it parses dates correctly', () => {
+    const parsedDate = getDate(startDate)
+    expect(parsedDate.getTime()).toBe(startDate.getTime())
+
+    const parsedUnixDate = getDate(startDate.getTime() / 1000)
+    expect(parsedUnixDate.getTime()).toBe(startDate.getTime())
+  })
+
+  test('it creates timeline correctly', () => {
+    const seconds = 20 * 60
+    const difference =
+      Math.round(
+        (endDate.getTime() / 1000 - startDate.getTime() / 1000) / seconds
+      ) + 1
+    const { items, hours } = getTimeline(startDate, endDate, seconds)
+    expect(items.length).toBe(difference)
+    expect(hours.length).toBe(difference)
+  })
+})