docs: update comments acc to stdlib conventions

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: passed
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---

Author: anandkaranubc

lib/node_modules/@stdlib/math/base/special/kernel-tanf/lib/main.js

@@ -93,18 +93,9 @@ function kernelTanf( x, iy ) {
 	z = x * x;
 
 	/*
-	* Split up the polynomial into small independent terms to give
-	* opportunities for parallel evaluation. The chosen splitting is
-	* micro-optimized for Athlons (XP, X64). It	costs 2 multiplications
-	* relative to Horner's method on sequential	machines.
+	* Split up the polynomial into small independent terms to give opportunities for parallel evaluation. The chosen splitting is a micro-optimization for specific hardware, as originally documented in FreeBSD's fdlibm. The splitting costs 2 multiplications relative to Horner's method on sequential machines.
 	*
-	* We add the small terms from lowest degree up for efficiency on
-	* non-sequential machines (the lowest degree termstend to be ready
-	* earlier). Apart from this, we don't care about order of
-	* operations, and don't need to care since we have precision to
-	* spare. However, the chosen splitting is good for accuracy too,
-	* and would give results as accurate as	Horner's method if the
-	* small terms were added from highest degree down.
+	* We add the small terms from lowest degree up for efficiency on non-sequential machines (the lowest degree terms tend to be ready earlier). Apart from this, we don't care about order of operations, and don't need to care since we have precision to spare. However, the chosen splitting is good for accuracy, too, and would give results as accurate as Horner's method if the small terms were added from highest degree down.
 	*/
 	r = T[ 4 ] + ( z * T[ 5 ] );
 	t = T[ 2 ] + ( z * T[ 3 ] );

lib/node_modules/@stdlib/math/base/special/kernel-tanf/src/main.c

@@ -68,18 +68,9 @@ float stdlib_base_kernel_tanf( const double x, const int32_t iy ) {
 	z = x * x;
 
 	/*
-	* Split up the polynomial into small independent terms to give
-	* opportunities for parallel evaluation. The chosen splitting is
-	* micro-optimized for Athlons (XP, X64). It	costs 2 multiplications
-	* relative to Horner's method on sequential	machines.
+	* Split up the polynomial into small independent terms to give opportunities for parallel evaluation. The chosen splitting is a micro-optimization for specific hardware, as originally documented in FreeBSD's fdlibm. The splitting costs 2 multiplications relative to Horner's method on sequential machines.
 	*
-	* We add the small terms from lowest degree up for efficiency on
-	* non-sequential machines (the lowest degree termstend to be ready
-	* earlier). Apart from this, we don't care about order of
-	* operations, and don't need to care since we have precision to
-	* spare. However, the chosen splitting is good for accuracy too,
-	* and would give results as accurate as	Horner's method if the
-	* small terms were added from highest degree down.
+	* We add the small terms from lowest degree up for efficiency on non-sequential machines (the lowest degree terms tend to be ready earlier). Apart from this, we don't care about order of operations, and don't need to care since we have precision to spare. However, the chosen splitting is good for accuracy, too, and would give results as accurate as Horner's method if the small terms were added from highest degree down.
 	*/
 	r = T[ 4 ] + ( z * T[ 5 ] );
 	t = T[ 2 ] + ( z * T[ 3 ] );