Search Options

Results per page
Sort
Preferred Languages
Advance

Results 11 - 20 of 92 for Approximates (0.32 sec)

  1. src/cmd/cover/doc.go

    it will process all the source files in a single package at a time
    (package-scope instrumentation is enabled via "-pkgcfg" option).
    
    When generated instrumented code, the cover tool computes approximate
    basic block information by studying the source. It is thus more
    portable than binary-rewriting coverage tools, but also a little less
    capable. For instance, it does not probe inside && and || expressions,
    Registered: Wed Jun 12 16:32:35 UTC 2024
    - Last Modified: Tue Oct 03 12:57:25 UTC 2023
    - 1.3K bytes
    - Viewed (0)
  2. src/cmd/trace/threadgen.go

    		// TODO(mknyszek): We don't have a state machine for threads, so approximate
    		// running threads with running Ps.
    		ctx.IncThreadStateCount(ctx.elapsed(start), traceviewer.ThreadStateRunning, 1)
    	}
    	if from.Executing() {
    		start := ev.Time()
    		viewerEv.Name = "proc stop"
    		viewerEv.Ts = ctx.elapsed(start)
    		// TODO(mknyszek): We don't have a state machine for threads, so approximate
    		// running threads with running Ps.
    Registered: Wed Jun 12 16:32:35 UTC 2024
    - Last Modified: Fri May 17 18:48:18 UTC 2024
    - 5.7K bytes
    - Viewed (0)
  3. src/math/j0.go

    //      1. For x<2.
    //         Since
    //              y0(x) = 2/pi*(j0(x)*(ln(x/2)+Euler) + x**2/4 - ...)
    //         therefore y0(x)-2/pi*j0(x)*ln(x) is an even function.
    //         We use the following function to approximate y0,
    //              y0(x) = U(z)/V(z) + (2/pi)*(j0(x)*ln(x)), z= x**2
    //         where
    //              U(z) = u00 + u01*z + ... + u06*z**6
    //              V(z) = 1  + v01*z + ... + v04*z**4
    Registered: Wed Jun 12 16:32:35 UTC 2024
    - Last Modified: Mon Apr 11 16:34:30 UTC 2022
    - 13.6K bytes
    - Viewed (0)
  4. src/math/sin.go

    // eliminated by contriving an extended precision modular arithmetic.
    //
    // Two polynomial approximating functions are employed.
    // Between 0 and pi/4 the sine is approximated by
    //      x  +  x**3 P(x**2).
    // Between pi/4 and pi/2 the cosine is represented as
    //      1  -  x**2 Q(x**2).
    //
    // ACCURACY:
    //
    //                      Relative error:
    Registered: Wed Jun 12 16:32:35 UTC 2024
    - Last Modified: Mon Apr 11 16:34:30 UTC 2022
    - 6.4K bytes
    - Viewed (0)
  5. tensorflow/compiler/mlir/lite/stablehlo/odml_converter/transforms/outline_composites.cc

        return custom_call.getCallTargetName() == "mhlo.erf";
      }
      return llvm::isa<chlo::ErfOp>(op);
    }
    
    // Builds a reference implementation of non-approximate GELU.
    func::FuncOp BuildGELUDecomposition(RankedTensorType type,
                                        PatternRewriter& rewriter,
                                        Block* insertion_point) {
    Registered: Sun Jun 16 05:45:23 UTC 2024
    - Last Modified: Fri May 17 17:58:54 UTC 2024
    - 9.6K bytes
    - Viewed (0)
  6. analysis/analysis-api-impl-base/tests/org/jetbrains/kotlin/analysis/api/impl/base/test/cases/components/expressionTypeProvider/AbstractHLExpressionTypeTest.kt

            super.configureTest(builder)
            builder.useDirectives(Directives)
        }
    
        object Directives : SimpleDirectivesContainer() {
            val APPROXIMATE_TYPE by stringDirective("approximate expression type")
        }
    
        companion object {
            private val renderer = KaTypeRendererForDebug.WITH_QUALIFIED_NAMES
        }
    Registered: Wed Jun 12 09:53:16 UTC 2024
    - Last Modified: Wed May 22 06:28:34 UTC 2024
    - 3K bytes
    - Viewed (0)
  7. src/math/j1.go

    //      2. For x<2.
    //         Since
    //              y1(x) = 2/pi*(j1(x)*(ln(x/2)+Euler)-1/x-x/2+5/64*x**3-...)
    //         therefore y1(x)-2/pi*j1(x)*ln(x)-1/x is an odd function.
    //         We use the following function to approximate y1,
    //              y1(x) = x*U(z)/V(z) + (2/pi)*(j1(x)*ln(x)-1/x), z= x**2
    //         where for x in [0,2] (abs err less than 2**-65.89)
    //              U(z) = U0[0] + U0[1]*z + ... + U0[4]*z**4
    Registered: Wed Jun 12 16:32:35 UTC 2024
    - Last Modified: Mon Apr 11 16:34:30 UTC 2022
    - 13.3K bytes
    - Viewed (0)
  8. src/cmd/vendor/golang.org/x/text/cases/info.go

    // (e.g. [ALetter] [ExtendNumLet] [Katakana] [ExtendNumLet] [ALetter] and
    // [ALetter] [Numeric] [MidNum] [Numeric] [ALetter].)
    //
    // Note 2: the rule for Mid is very approximate, but works in most cases. To
    // improve, we could store the categories in the trie value and use a FA to
    // manage breaks. See TODO comment above.
    //
    // Note 3: according to the spec, it is possible for the Extend category to
    Registered: Wed Jun 12 16:32:35 UTC 2024
    - Last Modified: Wed Jan 24 13:01:26 UTC 2024
    - 2.9K bytes
    - Viewed (0)
  9. platforms/core-configuration/kotlin-dsl/src/test/kotlin/org/gradle/kotlin/dsl/resolver/SourcePathProviderTest.kt

        /**
         * This unit test can't rely on `BuildSrcClassPathModeConfigurationAction`
         * it is testing the fallback behavior of [SourcePathProvider]
         */
        @Test
        fun `given buildSrc folder, it will fallback to approximate buildSrc source roots`() {
            withFolders {
                "project" {
                    "buildSrc/src/main" {
                        +"foo"
                        +"bar"
                    }
                }
    Registered: Wed Jun 12 18:38:38 UTC 2024
    - Last Modified: Tue Dec 19 17:35:41 UTC 2023
    - 7.1K bytes
    - Viewed (0)
  10. src/math/erf.go

    //         Remark: here we use the taylor series expansion at x=1.
    //              erf(1+s) = erf(1) + s*Poly(s)
    //                       = 0.845.. + P1(s)/Q1(s)
    //         That is, we use rational approximation to approximate
    //                      erf(1+s) - (c = (single)0.84506291151)
    //         Note that |P1/Q1|< 0.078 for x in [0.84375,1.25]
    //         where
    //              P1(s) = degree 6 poly in s
    Registered: Wed Jun 12 16:32:35 UTC 2024
    - Last Modified: Mon Apr 11 16:34:30 UTC 2022
    - 11.5K bytes
    - Viewed (0)
Back to top