Changeset 396 for trunk/readexp.tcl


Ignore:
Timestamp:
Dec 4, 2009 5:05:28 PM (11 years ago)
Author:
toby
Message:

# on 2001/06/29 17:54:33, toby did:
brace expr's for better speed
support refinement options: Marquardt, convergence, LeBail? damping
get tmin,tmax (for Cheb. computation)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/readexp.tcl

    • Property rcs:date changed from 2001/05/11 16:09:08 to 2001/06/29 17:54:33
    • Property rcs:lines changed from +14 -5 to +147 -103
    • Property rcs:rev changed from 1.26 to 1.27
    r387 r396  
    102102    # loop over phases
    103103    foreach iph {1 2 3 4 5 6 7 8 9} {
    104         set i5s [expr ($iph - 1)*5]
    105         set i5e [expr $i5s + 4]
     104        set i5s [expr {($iph - 1)*5}]
     105        set i5e [expr {$i5s + 4}]
    106106        set flag [string trim [string range $line $i5s $i5e]]
    107107        if {$flag == ""} {set flag 0}
     
    123123        set natom [phaseinfo $iph natoms]
    124124        if {$natom != [llength $expmap(atomlist_$iph)]} {
    125             set expmap(atomlist_$iph) [lrange $expmap(atomlist_$iph) 0 [expr $natom-1]]
     125            set expmap(atomlist_$iph) [lrange $expmap(atomlist_$iph) 0 [expr {$natom-1}]]
    126126        }
    127127    }
     
    131131    set expmap(powderlist) {}
    132132    for {set i 0} {$i < $nhist} {incr i} {
    133         set ihist [expr $i + 1]
    134         if {[expr $i % 12] == 0} {
     133        set ihist [expr {$i + 1}]
     134        if {[expr {$i % 12}] == 0} {
    135135            incr n
    136136            set line [readexp " EXPR  HTYP$n"]
     
    167167        # loop over phases
    168168        foreach iph {1 2 3 4 5 6 7 8 9} {
    169             set i5s [expr ($iph - 1)*5]
    170             set i5e [expr $i5s + 4]
     169            set i5s [expr {($iph - 1)*5}]
     170            set i5e [expr {$i5s + 4}]
    171171            set flag [string trim [string range $line $i5s $i5e]]
    172172            if {$flag == ""} {set flag 0}
     
    210210
    211211    # pad value to $chars
    212     set l0 [expr $chars - 1]
     212    set l0 [expr {$chars - 1}]
    213213    set value [string range "$value                                           " 0 $l0]
    214214
     
    217217        set l1 $chars
    218218    } else {
    219         set l0 [expr $start - 2]
    220         set l1 [expr $start + $chars - 1]
     219        set l0 [expr {$start - 2}]
     220        set l1 [expr {$start + $chars - 1}]
    221221        set ret [string range $exparray($key) 0 $l0]
    222222    }
     
    249249proc validreal {val length decimal} {
    250250    upvar $val value
    251     if [catch {expr $value}] {return 0}
     251    if [catch {expr {$value}}] {return 0}
    252252    if [catch {
    253253        set tmp [format "%${length}.${decimal}f" $value]
     
    268268    if {$value == ""} {set value 0}
    269269    if [catch {
    270         set tmp [expr round($value)]
     270        set tmp [expr {round($value)}]
    271271        if {$tmp != $value} {return 0}
    272272        set value [format "%${length}d" $tmp]
     
    307307#     cycles    -- number of GENLES cycles (*)
    308308#     title     -- the overall title (*)
     309#     convg     -- convergence criterion: -200 to 200 (*)
     310#     marq      -- Marquardt damping factor: 1.0 to 9.99 (*)
    309311proc expinfo {parm "action get" "value {}"} {
    310312    switch ${parm}-$action {
     
    315317            setexp "      DESCR" "  $value" 2 68
    316318        }
    317 
    318319        cycles-get {
    319320            return [string trim [cdatget MXCY]]
     
    331332            if ![validint value 1] {return 0}
    332333            cdatset PRNT [format %3d $value]
     334        }
     335        convg-get {
     336            set cvg [string trim [cdatget CVRG]]
     337            if {$cvg == ""} {return -200}
     338            if [catch {expr {$cvg}}] {return -200}
     339            return $cvg
     340        }
     341        convg-set {
     342            if ![validint value 1] {return 0}
     343            set value [expr {-200>$value?-200:$value}]
     344            set value [expr {200<$value?200:$value}]
     345            cdatset CVRG [format %4d $value]
     346        }
     347        marq-get {
     348            set mar [string trim [cdatget MARQ]]
     349            if {$mar == ""} {return 1.0}
     350            if [catch {expr $mar}] {return 1.}
     351            return $mar
     352        }
     353        marq-set {
     354            if [catch {
     355                set value [expr {1.0>$value?1.0:$value}]
     356                set value [expr {9.99<$value?9.99:$value}]
     357            }] {return 0}
     358            if ![validreal value 4 2] {return 0}
     359            cdatset MARQ $value
    333360        }
    334361        default {
     
    583610        ODFcoef*-get {
    584611            regsub ODFcoef $parm {} term
    585             set k [expr ($term+5)/6]
     612            set k [expr {($term+5)/6}]
    586613            if {$k <= 9} {set k " $k"}
    587             set j [expr (($term-1) % 6)+1]
     614            set j [expr {(($term-1) % 6)+1}]
    588615            set lineB [readexp "CRS$phase  ODF${k}B"]
    589             set j0 [expr  ($j-1) *10]
    590             set j1 [expr $j0 + 9]
     616            set j0 [expr { ($j-1) *10}]
     617            set j1 [expr {$j0 + 9}]
    591618            set val [string trim [string range $lineB $j0 $j1]]
    592619            if {$val == ""} {return 0.0}
     
    596623            regsub ODFcoef $parm {} term
    597624            if ![validreal value 10 3] {return 0}
    598             set k [expr ($term+5)/6]
     625            set k [expr {($term+5)/6}]
    599626            if {$k <= 9} {set k " $k"}
    600             set j [expr (($term-1) % 6)+1]
    601             set col [expr  ($j-1)*10 + 1]
     627            set j [expr {(($term-1) % 6)+1}]
     628            set col [expr { ($j-1)*10 + 1}]
    602629            setexp "CRS$phase  ODF${k}B" $value $col 10
    603630        }
     
    641668            set val [string trim [string range [readexp "CRS$phase  ODF"] 5 9]]
    642669            for {set i 1} {$i <= $val} {incr i 6} {
    643                 set k [expr 1+($i-1)/6]
     670                set k [expr {1+($i-1)/6}]
    644671                if {$k <= 9} {set k " $k"}
    645672                set lineA [readexp "CRS$phase  ODF${k}A"]
    646673                set k 0
    647674                for {set j $i} {$j <= $val && $j < $i+6} {incr j} {
    648                     set j0 [expr ($k)*10]
    649                     set j1 [expr $j0 + 9]
     675                    set j0 [expr {($k)*10}]
     676                    set j1 [expr {$j0 + 9}]
    650677                    lappend vallist [string trim [string range $lineA $j0 $j1]]
    651678                    incr k
     
    680707                    }
    681708                }
    682                 set col1 [expr $col + 1]
     709                set col1 [expr {$col + 1}]
    683710                foreach n [lrange $item 0 2] {
    684711                    if ![validint n 3] {return 0}
     
    786813                    catch {
    787814                        # get the trace
    788                         set value [expr ( \
     815                        set value [expr {( \
    789816                                [string range [readexp ${key}B] 0 9] + \
    790817                                [string range [readexp ${key}B] 10 19] + \
    791                                 [string range [readexp ${key}B] 20 29])/3.]
     818                                [string range [readexp ${key}B] 20 29])/3.}]
    792819                    }
    793820                    validreal value 10 6
     
    962989#     tofangle -- detector angle (TOF only)
    963990#     foextract  -- Fobs extraction flag (*)
     991#     LBdamp  -- LeBail damping value (*)
     992#     tmin/tmax -- minimum & maximum usable 2theta/TOF/energy
    964993proc histinfo {histlist parm "action get" "value {}"} {
    965994    global expgui
     
    9991028                }
    10001029            }
     1030            LBdamp-get {
     1031                set v [string trim [string range [readexp "${key} EPHAS"] 54 54]]
     1032                if {$v == ""} {return 0}
     1033                return $v
     1034            }
     1035            LBdamp-set {
     1036                if ![validint value 5] {return 0}
     1037                setexp "${key} EPHAS" $value 51 5
     1038            }
    10011039            title-get {
    10021040                return [string trim [readexp "${key}  HNAM"] ]
     
    12161254                if ![validint value 5] {return 0}
    12171255                if {$oldval < $value} {
    1218                     set line1  [expr 2 + ($oldval - 1) / 4]
    1219                     set line2  [expr 1 + ($value - 1) / 4]
     1256                    set line1  [expr {2 + ($oldval - 1) / 4}]
     1257                    set line2  [expr {1 + ($value - 1) / 4}]
    12201258                    for {set i $line1} {$i <= $line2} {incr i} {
    12211259                        # create a blank entry if needed
     
    12241262                    incr oldval
    12251263                    for {set num $oldval} {$num <= $value} {incr num} {
    1226                         set f1 [expr 15*(($num - 1) % 4)]
    1227                         set f2 [expr 15*(1 + ($num - 1) % 4)-1]
    1228                         set line  [expr 1 + ($num - 1) / 4]
     1264                        set f1 [expr {15*(($num - 1) % 4)}]
     1265                        set f2 [expr {15*(1 + ($num - 1) % 4)-1}]
     1266                        set line  [expr {1 + ($num - 1) / 4}]
    12291267                        if {[string trim [string range [readexp ${key}BAKGD$line] $f1 $f2]] == ""} {
    1230                             set f1 [expr 15*(($num - 1) % 4)+1]
     1268                            set f1 [expr {15*(($num - 1) % 4)+1}]
    12311269                            setexp ${key}BAKGD$line 0.0 $f1 15                 
    12321270                        }
     
    12471285                } else {
    12481286                    setexp "${key}BAKGD "  "N" 15 1
    1249                 }           
     1287                }
    12501288            }
    12511289            bdamp-get {
     
    12591297            bterm*-get {
    12601298                regsub bterm $parm {} num
    1261                 set f1 [expr 15*(($num - 1) % 4)]
    1262                 set f2 [expr 15*(1 + ($num - 1) % 4)-1]
    1263                 set line  [expr 1 + ($num - 1) / 4]
     1299                set f1 [expr {15*(($num - 1) % 4)}]
     1300                set f2 [expr {15*(1 + ($num - 1) % 4)-1}]
     1301                set line  [expr {1 + ($num - 1) / 4}]
    12641302                return [string trim [string range [readexp ${key}BAKGD$line] $f1 $f2] ]
    12651303            }
     
    12671305                regsub bterm $parm {} num
    12681306                if ![validreal value 15 6] {return 0}
    1269                 set f1 [expr 15*(($num - 1) % 4)+1]
    1270                 set line  [expr 1 + ($num - 1) / 4]
     1307                set f1 [expr {15*(($num - 1) % 4)+1}]
     1308                set line  [expr {1 + ($num - 1) / 4}]
    12711309                setexp ${key}BAKGD$line $value $f1 15
    12721310            }
     
    12761314            tofangle-get {
    12771315                return [string trim [string range [readexp "${key}BNKPAR"] 10 19]]
     1316            }
     1317            tmin-get {
     1318                return [string trim [string range [readexp "${key} TRNGE"] 0 9]]
     1319            }
     1320            tmax-get {
     1321                return [string trim [string range [readexp "${key} TRNGE"] 10 19]]
    12781322            }
    12791323            default {
     
    13091353        switch -glob ${parm}-$action {
    13101354            extmeth-get {
    1311                 set i1 [expr ($phase - 1)*5]
    1312                 set i2 [expr $i1 + 4]
     1355                set i1 [expr {($phase - 1)*5}]
     1356                set i2 [expr {$i1 + 4}]
    13131357                return [string trim [string range [readexp "HST $hist EPHAS"] $i1 $i2]]
    13141358            }
    13151359            extmeth-set {
    1316                 set i1 [expr ($phase - 1)*5 + 1]
     1360                set i1 [expr {($phase - 1)*5 + 1}]
    13171361                if ![validint value 5] {return 0}
    13181362                setexp "HST $hist EPHAS" $value $i1 5
     
    13641408                setexp "${key}PRCF " $value 6 5
    13651409                # now check that all needed entries exist
    1366                 set lines [expr 1 + ($value - 1) / 4]
     1410                set lines [expr {1 + ($value - 1) / 4}]
    13671411                for {set i 1} {$i <= $lines} {incr i} {
    13681412                    makeexprec "${key}PRCF $i"
     
    13861430            pterm*-get {
    13871431                regsub pterm $parm {} num
    1388                 set f1 [expr 15*(($num - 1) % 4)]
    1389                 set f2 [expr 15*(1 + ($num - 1) % 4)-1]
    1390                 set line  [expr 1 + ($num - 1) / 4]
     1432                set f1 [expr {15*(($num - 1) % 4)}]
     1433                set f2 [expr {15*(1 + ($num - 1) % 4)-1}]
     1434                set line  [expr {1 + ($num - 1) / 4}]
    13911435                return [string trim [string range [readexp "${key}PRCF $line"] $f1 $f2] ]
    13921436            }
     
    13941438                if ![validreal value 15 6] {return 0}
    13951439                regsub pterm $parm {} num
    1396                 set f1 [expr 1+ 15*(($num - 1) % 4)]
    1397                 set line  [expr 1 + ($num - 1) / 4]
     1440                set f1 [expr {1+ 15*(($num - 1) % 4)}]
     1441                set line  [expr {1 + ($num - 1) / 4}]
    13981442                setexp "${key}PRCF $line" $value $f1 15
    13991443            }
    14001444            pref*-get {
    14011445                regsub pref $parm {} num
    1402                 set f [expr 24+$num]
     1446                set f [expr {24+$num}]
    14031447                if {[string toupper [string range [readexp "${key}PRCF  "] $f $f]] == "Y"} {
    14041448                    return 1
     
    14081452            pref*-set {
    14091453                regsub pref $parm {} num
    1410                 set f [expr 25+$num]
     1454                set f [expr {25+$num}]
    14111455                if $value {
    14121456                    setexp ${key}PRCF "Y" $f 1
     
    16001644            # don't delete a non-existing entry
    16011645            if {$number > $nterms} {return 0}
    1602             set val [expr $nterms - 1]
     1646            set val [expr {$nterms - 1}]
    16031647            validint val 5
    16041648            setexp $key $val 1 5
    16051649            for {set i1 $number} {$i1 < $nterms} {incr i1} {
    1606                 set i2 [expr 1 + $i1]
     1650                set i2 [expr {1 + $i1}]
    16071651                # move the contents of constraint #i2 -> i1
    16081652                if {$i1 > 9} {
    1609                     set k1 [expr ($i1+1)/10]
     1653                    set k1 [expr {($i1+1)/10}]
    16101654                    set l1 $i1
    16111655                } else {
     
    16161660                # number of constraint lines for #i1
    16171661                set n1 [string trim [string range [readexp ${key1}] \
    1618                         [expr ($i1%10)*5] [expr 4+(($i1%10)*5)]] ]
     1662                        [expr {($i1%10)*5}] [expr {4+(($i1%10)*5)}]] ]
    16191663                if {$i2 > 9} {
    1620                     set k2 [expr ($i2+1)/10]
     1664                    set k2 [expr {($i2+1)/10}]
    16211665                    set l2 $i2
    16221666                } else {
     
    16271671                # number of constraint lines for #i2
    16281672                set n2 [string trim [string range [readexp ${key2}] \
    1629                         [expr ($i2%10)*5] [expr 4+(($i2%10)*5)]] ]
     1673                        [expr {($i2%10)*5}] [expr {4+(($i2%10)*5)}]] ]
    16301674                set val $n2
    16311675                validint val 5
    16321676                # move the # of terms
    1633                 setexp $key1 $val [expr 1+(($i1%10)*5)] 5
     1677                setexp $key1 $val [expr {1+(($i1%10)*5)}] 5
    16341678                # move the terms
    16351679                for {set j 1} {$j <= $n2} {incr j 1} {
     
    16391683                }
    16401684                # delete any remaining lines
    1641                 for {set j [expr $n2+1]} {$j <= $n1} {incr j 1} {
     1685                for {set j [expr {$n2+1}]} {$j <= $n1} {incr j 1} {
    16421686                    delexp "LEQV PF${term}${l1}$j"
    16431687                }
     
    16461690            # clear the last term
    16471691            if {$nterms > 9} {
    1648                 set i [expr ($nterms+1)/10]
     1692                set i [expr {($nterms+1)/10}]
    16491693            } else {
    16501694                set i " "
    16511695            }
    16521696            set key "LEQV PF$term  $i"
    1653             set cb [expr ($nterms%10)*5]
    1654             set ce [expr 4+(($nterms%10)*5)]
     1697            set cb [expr {($nterms%10)*5}]
     1698            set ce [expr {4+(($nterms%10)*5)}]
    16551699            set n2 [string trim [string range [readexp ${key}] $cb $ce] ]
    16561700            incr cb
     
    16721716            if {$number > $nterms} {return 0}
    16731717            if {$number > 9} {
    1674                 set k1 [expr ($number+1)/10]
     1718                set k1 [expr {($number+1)/10}]
    16751719                set l1 $number
    16761720            } else {
     
    16811725            # old number of constraint lines
    16821726            set n1 [string trim [string range [readexp ${key1}] \
    1683                     [expr ($number%10)*5] [expr 4+(($number%10)*5)]] ]
     1727                    [expr {($number%10)*5}] [expr {4+(($number%10)*5)}]] ]
    16841728            # number of new constraints
    16851729            set j2 [llength $value]
    16861730            # number of new constraint lines
    1687             set val [set n2 [expr ($j2 + 2)/3]]
     1731            set val [set n2 [expr {($j2 + 2)/3}]]
    16881732            # store the new # of lines
    16891733            validint val 5
    1690             setexp $key1 $val [expr 1+(($number%10)*5)] 5
     1734            setexp $key1 $val [expr {1+(($number%10)*5)}] 5
    16911735
    16921736            # loop over the # of lines in the old or new, whichever is greater
    16931737            set v0 0
    1694             for {set j 1} {$j <= [expr ($n1 > $n2) ? $n1 : $n2]} {incr j 1} {
     1738            for {set j 1} {$j <= [expr {($n1 > $n2) ? $n1 : $n2}]} {incr j 1} {
    16951739                set key "LEQV PF${term}${l1}$j"
    16961740                # were there more lines in the old?
     
    17081752                # add the three constraints to the line
    17091753                foreach s {3 23 43} \
    1710                         item [lrange $value $v0 [expr 2+$v0]] {
     1754                        item [lrange $value $v0 [expr {2+$v0}]] {
    17111755                    if {$item != ""} {
    17121756                        set val [format %-10s%9.3f \
     
    17421786
    17431787            if {$nterms > 9} {
    1744                 set k1 [expr ($nterms+1)/10]
     1788                set k1 [expr {($nterms+1)/10}]
    17451789                set l1 $nterms
    17461790            } else {
     
    17531797            set j2 [llength $value]
    17541798            # number of new constraint lines
    1755             set val [set n2 [expr ($j2 + 2)/3]]
     1799            set val [set n2 [expr {($j2 + 2)/3}]]
    17561800            # store the new # of lines
    17571801            validint val 5
    1758             setexp $key1 $val [expr 1+(($nterms%10)*5)] 5
     1802            setexp $key1 $val [expr {1+(($nterms%10)*5)}] 5
    17591803
    17601804            # loop over the # of lines to be added
     
    17651809                # add the three constraints to the line
    17661810                foreach s {3 23 43} \
    1767                         item [lrange $value $v0 [expr 2+$v0]] {
     1811                        item [lrange $value $v0 [expr {2+$v0}]] {
    17681812                    if {$item != ""} {
    17691813                        set val [format %-10s%9.3f \
     
    17841828            }
    17851829            if {$number > 9} {
    1786                 set i [expr ($number+1)/10]
     1830                set i [expr {($number+1)/10}]
    17871831            } else {
    17881832                set i " "
     
    17941838           
    17951839            set numline [string trim [string range [readexp ${key}] \
    1796                     [expr ($number%10)*5] [expr 4+(($number%10)*5)]] ]
     1840                    [expr {($number%10)*5}] [expr {4+(($number%10)*5)}]] ]
    17971841            if {$number == 0} {return $numline}
    17981842            set clist {}
     
    18621906        pterm*-get {
    18631907            regsub pterm $parm {} num
    1864             set f1 [expr 15*(($num - 1) % 4)]
    1865             set f2 [expr 15*(1 + ($num - 1) % 4)-1]
    1866             set line  [expr 1 + ($num - 1) / 4]
     1908            set f1 [expr {15*(($num - 1) % 4)}]
     1909            set f2 [expr {15*(1 + ($num - 1) % 4)-1}]
     1910            set line  [expr {1 + ($num - 1) / 4}]
    18671911            return [string trim [string range [\
    18681912                        readexp "${key}PRCF${set}$line"] $f1 $f2] ]
     
    18701914        pref*-get {
    18711915            regsub pref $parm {} num
    1872             set f [expr 24+$num]
     1916            set f [expr {24+$num}]
    18731917            if {[string toupper [string range [readexp "${key}PRCF$set"] $f $f]] == "Y"} {
    18741918                return 1
     
    20922136    }
    20932137    # change the number of atoms in the phase
    2094     phaseinfo $phase natoms set [expr [phaseinfo $phase natoms] -1]
     2138    phaseinfo $phase natoms set [expr {[phaseinfo $phase natoms] -1}]
    20952139
    20962140    # now adjust numbers in "EXPR ATYP" records and delete, if needed.
     
    21422186    }
    21432187
    2144     set G(1,1) [expr $a * $a]
    2145     set G(2,2) [expr $b * $b]
    2146     set G(3,3) [expr $c * $c]
    2147     set G(1,2) [expr $a * $b * cos($gamma*0.017453292519943)]
     2188    set G(1,1) [expr {$a * $a}]
     2189    set G(2,2) [expr {$b * $b}]
     2190    set G(3,3) [expr {$c * $c}]
     2191    set G(1,2) [expr {$a * $b * cos($gamma*0.017453292519943)}]
    21482192    set G(2,1) $G(1,2)
    2149     set G(1,3) [expr $a * $c * cos($beta *0.017453292519943)]
     2193    set G(1,3) [expr {$a * $c * cos($beta *0.017453292519943)}]
    21502194    set G(3,1) $G(1,3)
    2151     set G(2,3) [expr $b * $c * cos($alpha*0.017453292519943)]
     2195    set G(2,3) [expr {$b * $c * cos($alpha*0.017453292519943)}]
    21522196    set G(3,2) $G(2,3)
    21532197
     
    21552199    set v2 0.0
    21562200    foreach i {1 2 3} {
    2157         set J [expr ($i%3) + 1]
    2158         set K [expr (($i+1)%3) + 1]
    2159         set v2 [expr $v2+ $G(1,$i)*($G(2,$J)*$G(3,$K)-$G(3,$J)*$G(2,$K))]
     2201        set J [expr {($i%3) + 1}]
     2202        set K [expr {(($i+1)%3) + 1}]
     2203        set v2 [expr {$v2+ $G(1,$i)*($G(2,$J)*$G(3,$K)-$G(3,$J)*$G(2,$K))}]
    21602204    }
    21612205    if {$v2 > 0} {
    2162         set v [expr sqrt($v2)]
     2206        set v [expr {sqrt($v2)}]
    21632207        foreach i {1 2 3} {
    2164             set i1 [expr ($i%3) + 1]
    2165             set i2 [expr (($i+1)%3) + 1]
     2208            set i1 [expr {($i%3) + 1}]
     2209            set i2 [expr {(($i+1)%3) + 1}]
    21662210            foreach j {1 2 3} {
    2167                 set j1 [expr ($j%3) + 1]
    2168                 set j2 [expr (($j+1)%3) + 1]
    2169                 set C($j,$i) [expr (\
     2211                set j1 [expr {($j%3) + 1}]
     2212                set j2 [expr {(($j+1)%3) + 1}]
     2213                set C($j,$i) [expr {(\
    21702214                        $G($i1,$j1) * $G($i2,$j2) - \
    21712215                        $G($i1,$j2)  * $G($i2,$j1)\
    2172                         )/ $v]
    2173             }
    2174         }
    2175         set A(1,2) [expr 0.5 * ($C(1,2) + $C(2,1)) / sqrt( $C(1,1)* $C(2,2) )]
    2176         set A(1,3) [expr 0.5 * ($C(1,3) + $C(3,1)) / sqrt( $C(1,1)* $C(3,3) )]
    2177         set A(2,3) [expr 0.5 * ($C(2,3) + $C(3,2)) / sqrt( $C(2,2)* $C(3,3) )]
     2216                        )/ $v}]
     2217            }
     2218        }
     2219        set A(1,2) [expr {0.5 * ($C(1,2)+$C(2,1)) / sqrt( $C(1,1)* $C(2,2) )}]
     2220        set A(1,3) [expr {0.5 * ($C(1,3)+$C(3,1)) / sqrt( $C(1,1)* $C(3,3) )}]
     2221        set A(2,3) [expr {0.5 * ($C(2,3)+$C(3,2)) / sqrt( $C(2,2)* $C(3,3) )}]
    21782222        foreach i {1 1 2} j {2 3 3} {
    2179             set A($i,$j) [expr 0.5 * ($C($i,$j) + $C($j,$i)) / \
    2180                     sqrt( $C($i,$i)* $C($j,$j) )]
     2223            set A($i,$j) [expr {0.5 * ($C($i,$j) + $C($j,$i)) / \
     2224                    sqrt( $C($i,$i)* $C($j,$j) )}]
    21812225            # clean up roundoff
    21822226            if {abs($A($i,$j)) < 1e-5} {set A($i,$j) 0.0}
     
    21882232    }
    21892233    return "$Uequiv $Uequiv $Uequiv \
    2190             [expr $Uequiv * $A(1,2)] \
    2191             [expr $Uequiv * $A(1,3)] \
    2192             [expr $Uequiv * $A(2,3)]"
    2193 }
     2234            [expr {$Uequiv * $A(1,2)}] \
     2235            [expr {$Uequiv * $A(1,3)}] \
     2236            [expr {$Uequiv * $A(2,3)}]"
     2237}
Note: See TracChangeset for help on using the changeset viewer.