Merge remote-tracking branch 'origin/fix-casts' into flonum-platform

Author: JonasRegehr

Makefile

@@ -58,7 +58,7 @@ hooks:
 	echo "make fmt" >>.git/hooks/pre-commit
 
 fmt:
-	raco fmt -i $(shell find . -name '*.rkt')
+	@raco fmt -i $(shell find egg-herbie/ src/ infra/ -name '*.rkt')
 
 # This rule is run by herbie.uwplse.org on every commit to Github.
 # It does not restart the demo server, but it does pull new static content

bench/graphics/log-transform.fpcore

@@ -0,0 +1,11 @@
+; This example is taken from the Image Processing domain and referred to 
+; as "Logarithmic Transform". This in its basic form is used to bring out
+; details in dark parts of an image. This instantiation of the idea is for 1D
+; as opposed to 2D images.
+
+(FPCore (c x y)
+  :name "Logarithmic Transform"
+  :alt
+    (* c (log1p (* (expm1 x) y)))
+
+  (* c (log (+ 1.0 (* (- (pow E x) 1.0) y)))))

infra/testApi.mjs

@@ -3,12 +3,13 @@ import { strict as assert } from 'node:assert';  // use strict equality everywhe
 // Future TODO: before this API becomes set in stone/offered publicly, we should change the results of these methods to be just the output data rather than duplicating input values.
 
 // Reusable testing data
+const SAMPLE_SIZE = 8000
 const FPCoreFormula = '(FPCore (x) (- (sqrt (+ x 1)) (sqrt x)))'
 const FPCoreFormula2 = '(FPCore (x) (- (sqrt (+ x 1))))'
 const eval_sample = [[[1], -1.4142135623730951]]
 
 // improve endpoint
-const improveResponse = await callHerbie(`/improve?formula=${encodeURIComponent(FPCoreFormula2)}`, { method: 'GET' })
+const improveResponse = await fetch(makeEndpoint(`/improve?formula=${encodeURIComponent(FPCoreFormula2)}`), { method: 'GET' })
 assert.equal(improveResponse.status, 200)
 let redirect = improveResponse.url.split("/")
 const jobID = redirect[3].split(".")[0]
@@ -18,18 +19,18 @@ const jobID = redirect[3].split(".")[0]
 // assert.equal(improveHTML.length, improveHTMLexpectedCount, `HTML response character count should be ${improveHTMLexpectedCount} unless HTML changes.`)
 
 // timeline
-const timelineRSP = await callHerbie(`/timeline/${jobID}`, { method: 'GET' })
+const timelineRSP = await fetch(makeEndpoint(`/timeline/${jobID}`), { method: 'GET' })
 assert.equal(timelineRSP.status, 201)
 const timeline = await timelineRSP.json()
 assert.equal(timeline.length > 0, true)
 
 // Test with a likely missing job-id
-const badTimelineRSP = await callHerbie(`/timeline/42069`, { method: 'GET' })
+const badTimelineRSP = await fetch(makeEndpoint("/timeline/42069"), { method: 'GET' })
 assert.equal(badTimelineRSP.status, 404)
 
 // improve-start endpoint
 const URIencodedBody = "formula=" + encodeURIComponent(FPCoreFormula)
-const startResponse = await callHerbie(`/improve-start`, {
+const startResponse = await fetch(makeEndpoint("/api/start/improve"), {
   method: 'POST',
   headers: {
     'Content-Type': 'application/x-www-form-urlencoded',
@@ -38,122 +39,164 @@ const startResponse = await callHerbie(`/improve-start`, {
 })
 const testResult = (startResponse.status == 201 || startResponse.status == 202)
 assert.equal(testResult, true)
-const path = startResponse.headers.get("location")
+const improveResultPath = startResponse.headers.get("location")
+let counter = 0
+let cap = 100
+// Check status endpoint
+let checkStatus = await fetch(makeEndpoint(improveResultPath), { method: 'GET' })
+/*
+This is testing if the /api/start/improve test at the beginning has been completed. The cap and counter is a sort of timeout for the test. Ends up being 10 seconds max.
+*/
+while (checkStatus.status != 201 && counter < cap) {
+  counter += 1
+  checkStatus = await fetch(makeEndpoint(improveResultPath), { method: 'GET' })
+  await new Promise(r => setTimeout(r, 100)); // ms
+}
+assert.equal(checkStatus.statusText, 'Job complete')
 
 // up endpoint
-const up = await callHerbie("/up", { method: 'GET' })
+const up = await fetch(makeEndpoint("/up"), { method: 'GET' })
 assert.equal('Up', up.statusText)
 // TODO how do I test down state?
 
 // Sample endpoint
-const sampleRSP = await callHerbie("/api/sample", { method: 'POST', body: JSON.stringify({ formula: FPCoreFormula2, seed: 5 }) })
+const sampleBody = {
+  method: 'POST',
+  body: JSON.stringify({ formula: FPCoreFormula2, seed: 5 })
+}
+const sampleRSP = await fetch(makeEndpoint("/api/sample"), sampleBody)
+const sampleAsyncResult = await callAsyncAndWaitJSONResult("/api/start/sample", sampleBody)
 const jid = sampleRSP.headers.get("x-herbie-job-id")
 assert.notEqual(jid, null)
-
 const sample = await sampleRSP.json()
+assertIdAndPath(sampleAsyncResult)
+assert.ok(sampleAsyncResult.points)
+assert.equal(sampleAsyncResult.points.length, SAMPLE_SIZE)
 assertIdAndPath(sample)
-
-const SAMPLE_SIZE = 8000
 assert.ok(sample.points)
-const points = sample.points
-assert.equal(points.length, SAMPLE_SIZE, `sample size should be ${SAMPLE_SIZE}`)
+assert.equal(sample.points.length, SAMPLE_SIZE, `sample size should be ${SAMPLE_SIZE}`)
 
-const sample2RPS = await callHerbie("/api/sample", { method: 'POST', body: JSON.stringify({ formula: FPCoreFormula2, seed: 5 }) })
+// Make second call to test that results are the same
+const sample2RPS = await fetch(makeEndpoint("/api/sample"), sampleBody)
 const jid2 = sample2RPS.headers.get("x-herbie-job-id")
 assert.notEqual(jid2, null)
 const sample2 = await sample2RPS.json()
-const points2 = sample2.points
 assertIdAndPath(sample2)
-assert.deepEqual(points[1], points2[1])
+assert.deepEqual(sample.points[1], sample2.points[1])
+
+//Explanations endpoint
+const explainBody = {
+  method: 'POST',
+  body: JSON.stringify({
+    formula: FPCoreFormula, sample: sample2.points
+  })
+}
+const explain = await (await fetch(makeEndpoint("/api/explanations"), explainBody)).json()
+assertIdAndPath(explain)
+assert.equal(explain.explanation.length > 0, true, 'explanation should not be empty');
+const explainAsyncResult = await callAsyncAndWaitJSONResult("/api/start/explanations", explainBody)
+assertIdAndPath(explainAsyncResult)
+assert.equal(explainAsyncResult.explanation.length > 0, true, 'explanation should not be empty');
 
 // Analyze endpoint
-const errors = await callHerbie("/api/analyze", {
+const errorsBody = {
   method: 'POST', body: JSON.stringify({
     formula: FPCoreFormula, sample: [[[
       14.97651307489794
     ], 0.12711304680349078]]
   })
-})
+}
+const errors = await (await fetch(makeEndpoint("/api/analyze"), errorsBody)).json()
 assertIdAndPath(errors)
 assert.deepEqual(errors.points, [[[14.97651307489794], "2.3"]])
+const analyzeAsyncResult = await callAsyncAndWaitJSONResult("/api/start/analyze", errorsBody)
+assertIdAndPath(analyzeAsyncResult)
+assert.deepEqual(analyzeAsyncResult.points, [[[14.97651307489794], "2.3"]])
+
+// Exacts endpoint
+const exactsBody = {
+  method: 'POST', body: JSON.stringify({
+    formula: FPCoreFormula2, sample: eval_sample
+  })
+}
+const exacts = await (await fetch(makeEndpoint("/api/exacts"), exactsBody)).json()
+assertIdAndPath(exacts)
+assert.deepEqual(exacts.points, [[[1], -1.4142135623730951]])
+const exactsAsyncResult = await callAsyncAndWaitJSONResult("/api/start/exacts", exactsBody)
+assertIdAndPath(exactsAsyncResult)
+assert.deepEqual(exactsAsyncResult.points, [[[1], -1.4142135623730951]])
+
+// Calculate endpoint
+const calculateBody = {
+  method: 'POST', body: JSON.stringify({
+    formula: FPCoreFormula2, sample: eval_sample
+  })
+}
+const calculate = await (await fetch(makeEndpoint("/api/calculate"), calculateBody)).json()
+assertIdAndPath(calculate)
+assert.deepEqual(calculate.points, [[[1], -1.4142135623730951]])
+const calculateAsyncResult = await callAsyncAndWaitJSONResult("/api/start/calculate", calculateBody)
+assertIdAndPath(calculateAsyncResult)
+assert.deepEqual(calculateAsyncResult.points, [[[1], -1.4142135623730951]])
 
 // Local error endpoint
-const localError = await callHerbie("/api/localerror", {
+const localErrorBody = {
   method: 'POST', body: JSON.stringify({
     formula: FPCoreFormula, sample: sample2.points
   })
-})
+}
+const localError = await (await fetch(makeEndpoint("/api/localerror"), localErrorBody)).json()
 assertIdAndPath(localError)
 assert.equal(localError.tree['avg-error'] > 0, true)
+const localErrorAsyncResult = await callAsyncAndWaitJSONResult("/api/start/localerror", localErrorBody)
+assertIdAndPath(localErrorAsyncResult)
+assert.equal(localErrorAsyncResult.tree['avg-error'] > 0, true)
 
-const json1 = JSON.stringify({
-  formula: FPCoreFormula, sample: [[[2.852044568544089e-150], 1e+308]], seed: 5
-})
-const json2 = JSON.stringify({
-  formula: FPCoreFormula, sample: [[[1.5223342548065899e-15], 1e+308]], seed: 5
-})
-const localError1 = await callHerbie("/api/localerror", {
-  method: 'POST', body: json1
-})
-const localError2 = await callHerbie("/api/localerror", {
-  method: 'POST', body: json2
-})
+const localError1 = await (await fetch(makeEndpoint("/api/localerror"), {
+  method: 'POST', body: JSON.stringify({
+    formula: FPCoreFormula, sample: [[[2.852044568544089e-150], 1e+308]], seed: 5
+  })
+})).json()
+const localError2 = await (await fetch(makeEndpoint("/api/localerror"), {
+  method: 'POST', body: JSON.stringify({
+    formula: FPCoreFormula, sample: [[[1.5223342548065899e-15], 1e+308]], seed: 5
+  })
+})).json()
 // Test that different sample points produce different job ids ensuring that different results are served for these inputs.
 assert.notEqual(localError1.job, localError2.job)
 
 // Alternatives endpoint
-
-const alternatives = await callHerbie("/api/alternatives", {
+const altBody = {
   method: 'POST', body: JSON.stringify({
     formula: FPCoreFormula, sample: [[[
       14.97651307489794
     ], 0.12711304680349078]]
   })
-})
+}
+const alternatives = await (await fetch(makeEndpoint("/api/alternatives"), altBody)).json()
 assertIdAndPath(alternatives)
 assert.equal(Array.isArray(alternatives.alternatives), true)
-
-//Explanations endpoint
-const sampleExp = (await (await fetch('http://127.0.0.1:8000/api/sample', { method: 'POST', body: JSON.stringify({ formula: FPCoreFormula2, seed: 5 }) })).json())
-const explain = await callHerbie("/api/explanations", {
-  method: 'POST', body: JSON.stringify({
-    formula: FPCoreFormula, sample: sampleExp.points
-  })
-})
-assertIdAndPath(explain)
-assert.equal(explain.explanation.length > 0, true, 'explanation should not be empty');
-// Exacts endpoint
-const exacts = await callHerbie("/api/exacts", {
-  method: 'POST', body: JSON.stringify({
-    formula: FPCoreFormula2, sample: eval_sample
-  })
-})
-assertIdAndPath(exacts)
-assert.deepEqual(exacts.points, [[[1], -1.4142135623730951]])
-
-// Calculate endpoint
-const calculate = await callHerbie("/api/calculate", {
-  method: 'POST', body: JSON.stringify({
-    formula: FPCoreFormula2, sample: eval_sample
-  })
-})
-assertIdAndPath(calculate)
-assert.deepEqual(calculate.points, [[[1], -1.4142135623730951]])
+const alternativesAsyncResult = await callAsyncAndWaitJSONResult("/api/start/alternatives", altBody)
+assertIdAndPath(alternativesAsyncResult)
+assert.equal(Array.isArray(alternativesAsyncResult.alternatives), true)
 
 // Cost endpoint
-const cost = await callHerbie("/api/cost", {
+const costBody = {
   method: 'POST', body: JSON.stringify({
     formula: FPCoreFormula2, sample: eval_sample
   })
-})
+}
+const cost = await (await fetch(makeEndpoint("/api/cost"), costBody)).json()
 assertIdAndPath(cost)
 assert.equal(cost.cost > 0, true)
+const costAsyncResult = await callAsyncAndWaitJSONResult("/api/start/cost", costBody)
+assertIdAndPath(costAsyncResult)
+assert.equal(costAsyncResult.cost > 0, true)
 
-// // MathJS endpoint
-const mathjs = await callHerbie("/api/mathjs", {
-  method: 'POST',
-  body: JSON.stringify({ formula: FPCoreFormula })
-})
+// MathJS endpoint
+const mathjs = await (await fetch(makeEndpoint("/api/mathjs"), {
+  method: 'POST', body: JSON.stringify({ formula: FPCoreFormula })
+})).json()
 assert.equal(mathjs.mathjs, "sqrt(x + 1.0) - sqrt(x)")
 
 // Translate endpoint
@@ -170,52 +213,46 @@ const expectedExpressions = {
 }
 
 for (const e in expectedExpressions) {
-  const translatedExpr = await callHerbie("/api/translate", {
+  const translatedExpr = await (await fetch(makeEndpoint("/api/translate"), {
     method: 'POST', body: JSON.stringify(
       { formula: FPCoreFormula, language: e })
-  })
+  })).json()
 
   assert.equal(translatedExpr.result, expectedExpressions[e])
 }
 
-let counter = 0
-let cap = 100
-// Check status endpoint
-let checkStatus = await callHerbie(path, { method: 'GET' })
-/*
-This is testing if the /improve-start test at the beginning has been completed. The cap and counter is a sort of timeout for the test. Ends up being 10 seconds max.
-*/
-while (checkStatus.status != 201 && counter < cap) {
-  counter += 1
-  checkStatus = await callHerbie(path, { method: 'GET' })
-  await new Promise(r => setTimeout(r, 100)); // ms
-}
-assert.equal(checkStatus.statusText, 'Job complete')
-
 // Results.json endpoint
-const jsonResults = await callHerbie("/results.json", { method: 'GET' })
+const jsonResults = await (await fetch(makeEndpoint("/results.json"), { method: 'GET' })).json()
 
 // Basic test that checks that there are the two results after the above test.
 // TODO add a way to reset the results.json file?
 assert.equal(jsonResults.tests.length, 2)
 
-async function callHerbie(endPoint, body) {
-  const url = new URL(`http://127.0.0.1:8000${endPoint}`)
-  const pathname = url.pathname
-  const rsp = await fetch(url, body)
-  if (pathname == "/improve" ||
-    pathname == "/improve-start" ||
-    pathname.includes("check-status") ||
-    pathname.includes("timeline") ||
-    pathname.includes("sample") ||
-    pathname == "/up") {
-    return rsp
-  } else {
-    return rsp.json()
-  }
+// Helper Functions
+function makeEndpoint(endpoint) {
+  return new URL(`http://127.0.0.1:8000${endpoint}`)
 }
 
 function assertIdAndPath(json) {
   assert.equal(json.job.length > 0, true)
   assert.equal(json.path.includes("."), true)
+}
+
+async function callAsyncAndWaitJSONResult(endpoint, body) {
+  let counter = 0
+  let cap = 100
+  // Check status endpoint
+  let jobInfo = await fetch(makeEndpoint(endpoint), body)
+  /*
+  The cap and counter is a sort of timeout for the test. Ends up being 10 seconds max.
+  */
+  const jobJSON = await jobInfo.json()
+  const checkStatus = await fetch(makeEndpoint(`/check-status/${jobJSON.job}`), { method: 'GET' })
+  while (checkStatus.status != 201 && counter < cap) {
+    counter += 1
+    checkStatus = await fetch(makeEndpoint(`/check-status/${jobJSON.job}`), { method: 'GET' })
+    await new Promise(r => setTimeout(r, 100)); // ms
+  }
+  const result = await fetch(makeEndpoint(`/api/result/${jobJSON.job}`), { method: 'GET' })
+  return await result.json()
 }