Exponentiel dans X-Path

Question

Le W3 a publié X-Path 3.0 qui peut gérer les suivants en conséquence.

À ce stade, mon environnement est toujours X-Path 2.0, d'où le problème auquel je suis confronté.

aide Veuillez comment puis-je obtenir cette course dans X-Path,

10 * 10^3; 

Le scénario donné comme suit,

1) Decimals: '3'; 
2) Weight: '99'; 

L'idée ici est d'obtenir le poids final basé sur la Décimales Le résultat ici serait '0.099'.

Pour moi ce faire, il me faudrait prendre

(99 div (10 * 10^3)); 

La question,
Comment puis-je obtenir 10^3 en utilisant X-Path 2.0.
Ou y at-il d'autres façons dont les images fixes intègrent X-Path mais sous un angle différent?

Merci Communauté.

Answer 1

I. Voici une expression XPath 2.0 qui produit le résultat de la multiplication un nombre entier par une puissance entière positive ou négative de 10.

On note le nombre entier par $n et la puissance par $decPow.

Aussi, j'ai choisi pour itérer $decPow dans l'intervalle [-3, 3]:

for $n in 999, $decPow in (-4, -3, -2, -1, 0, 1, 2, 3), 
    $n-length in string-length(string($n)), 
    $zeros in string-join(for $i in 1 to abs($decPow) 
           return '0', 
           '') 
    return 
    if($decPow ge 0) 
     then 
      concat($n, $zeros) 
      else 
      if(abs($decPow) ge $n-length) 
       then 
       concat('0.', substring($zeros, $n-length +1), $n) 
       else 
       concat(
         substring(string($n), 1, abs(abs($decPow) - $n-length)), 
         '.', 
         substring(string($n), abs(abs($decPow) - $n-length) +1) 
         ) 

Lorsque cette expression XPath 2.0 est évaluée, le résultat attendu, correcte est produite:

0.0999 0.999 9.99 99.9 999 9990 99900 999000 

Voici une validation en utilisant une transformation XSLT 2.0 (il évalue seulement l'expression et délivre le résultat):

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"> 
<xsl:output method="text"/> 

    <xsl:template match="/"> 
    <xsl:sequence select= 
    "for $n in 999, $decPow in (-4, -3, -2, -1, 0, 1, 2, 3), 
     $n-length in string-length(string($n)), 
     $zeros in string-join(for $i in 1 to abs($decPow) 
            return '0', 
            '') 
     return 
     if($decPow ge 0) 
      then 
       concat($n, $zeros) 
       else 
       if(abs($decPow) ge $n-length) 
        then 
        concat('0.', substring($zeros, $n-length +1), $n) 
        else 
        concat(
          substring(string($n), 1, abs(abs($decPow) - $n-length)), 
          '.', 
          substring(string($n), abs(abs($decPow) - $n-length) +1) 
          ) 
    "/> 
    </xsl:template> 
</xsl:stylesheet> 

Lorsque cette transformation est appliquée sur tout document XML (non utilisé), le résultat recherché, est produit correct:

0.0999 0.999 9.99 99.9 999 9990 99900 999000 

---

II. Dans le cas où l'on peut utiliser XSLT 2.0, alors la bibliothèque FXSL offre des fonctions d'exponentiation (la puissance peut être n'importe quel double - pas seulement entier) et les fonctions logarithmiques.

Voici une démonstration rapide:

<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" 
xmlns:xs="http://www.w3.org/2001/XMLSchema" 
xmlns:f="http://fxsl.sf.net/" 
exclude-result-prefixes="f xs" 
> 

    <xsl:import href="../f/func-exp.xsl"/> 

    <xsl:output method="text"/> 

    <xsl:template name="initial" match="/"> 
    <xsl:variable name="vPi" as="xs:double" 
     select="3.1415926535897932384626433832795E0"/> 
    <xsl:variable name="vE" as="xs:double" select="2.71828182845904E0"/> 

    <xsl:value-of select="f:log10(100E0)"/> 
    <xsl:text>&#xA;</xsl:text> 
    <xsl:value-of select="f:pow($vPi, $vE)"/> 
    <xsl:text>&#xA;</xsl:text> 
    <xsl:value-of select="f:pow(1024E0, 0.1E0)"/> 
    <xsl:text>&#xA;</xsl:text> 
    <xsl:value-of select="f:log2(1024E0)"/> 
    <xsl:text>&#xA;</xsl:text> 
    <xsl:value-of select="f:ln(f:pow($vE, $vPi))"/> 
    <xsl:text>&#xA;</xsl:text> 
    <xsl:value-of select="f:pow(f:pow($vE, $vPi), 1 div $vPi)"/> 
    <xsl:text>&#xA;</xsl:text> 
    <xsl:value-of select="f:pow(2 div 3, 99)"/> 

    ------------- 
<xsl:text/> 
    <xsl:value-of separator="'&#xA;'" select= 
    "for $vN in (-10,-9,-8,-7,-6,-5,-4,-3,-2,-1,0, 
        1,2,3,4,5,6,7,8,9,10) 
      return f:pow(10, $vN) 
    " 
    /> 
    </xsl:template> 
</xsl:stylesheet> 

Lorsque cette transformation est appliquée sur un résultat correct document XML (non utilisé), les recherchés, sont produits:

2.000000001444001 
22.459157762347406 
1.999999999538168 
9.999999955017541 
3.1415926541687718 
2.718281828960005 
3.6894816398697386E-18 

    ------------- 
1.0000000000000008E-10' 
'1.000000000000001E-9' 
'1.0000000000000008E-8' 
'1.0000000000000006E-7' 
'0.0000010000000000000004' 
'0.000010000000000000004' 
'0.00010000000000000005' 
'0.0010000000000000002' 
'0.010000000000000002' 
'0.1' 
'1' 
'10' 
'100' 
'1000' 
'10000' 
'100000' 
'1.0E6' 
'1.0E7' 
'1.0E8' 
'1.0E9' 
'1.0E10 

Answer 2

Si vous seulement besoin de puissances de dix et pas plus de 15 chiffres de précision, vous pouvez le convertir en double:

xs:double(concat($weight, "E", -$decimals)) 

Cela fonctionne, car une double valeur comme 99E-3 est 99 div 1000.0