Functional coverage tree: Difference between revisions

=={{header|Go}}==

{{trans|Kotlin}}

 

import "fmt"

fmt.Printf("%8.6f to %8.6f\n", diff, topCoverage+diff)

h2Basement[2].setCoverage(0.75) // restore to original value if required

 

{{out}}

Using a function from a text outline to an updated text outline.

 

{{Trans|Python}}

 

import qualified Data.Text as T

import Numeric (showFFloat)

 

data Coverage = Coverage

 

main :: IO ()

main =

 

updatedCoverageOutline :: T.Text -> T.Text

updatedCoverageOutline s =

let delimiter = "|"

indentedLines = T.lines s

 

weightedCoverage x xs =

totalWeight = foldr ((+) . snd) 0 cws

 

withResidueShares :: Float -> Tree Coverage -> Tree Coverage

let go fraction node =

let forest = subForest node

weightTotal = sum weights

nodeRoot = rootLabel node

 

 

forestFromLineIndents :: [(Int, T.Text)] -> [Tree T.Text]

forestFromLineIndents pairs =

let go [] = []

let (firstTreeLines, rest) = span ((n <) . fst) xs

 

indentLevelsFromLines :: [T.Text] -> [(Int, T.Text)]

indentLevelsFromLines xs =

indentUnit =

foldr

let w = (T.length . fst) x

(maxBound :: Int)

pairs

 

partialRecord :: [T.Text] -> Coverage

partialRecord xs =

 

defaultOrRead :: Float -> T.Text -> Float

defaultOrRead n txt = either (const n) fst $ T.rational txt

 

indentedLinesFromTree tab showRoot tree =

let go indent node =

showRoot indent (rootLabel node) :

(subForest node >>= go (T.append tab indent))

 

 

 

justifyRight :: Int -> a -> [a] -> [a]

 

showN :: Int -> Float -> String

{{Out}}

<pre>NAME_HIERARCHY | WEIGHT | COVERAGE | SHARE OF RESIDUE

=={{header|J}}==

 

 

NAME_HIERARCHY |WEIGHT |COVERAGE |

cleaning | | |

wine_cellar | |1 |

cinema | |0.75 |

 

 

'hier wspec cspec'=:|:}.<;._2;._2 raw

level=: (%+./) (0 i.~' '&=)"1 hier

weight=: (+ 0=]) ,".wspec

 

 

unrooted=: ([: merge <@(_1,$:@}.);.1)^:(0<#)

parent=: unrooted level

 

<code>unrooted</code> translates indentation information to a [[Tree_traversal#J:_Alternate_implementation|parent tree structure]]. However, the limitations of recursion require we distinguish the parent node from its children, so we use _1 to denote the parent node of the recursive intermediate result unrooted trees. (This works well with using arithmetic to adjust sub-tree indices based on the lengths of preceding sub-trees.) <code>merge</code> combines a boxed sequence of these subtrees to form a single tree - we also rely on the first node of each tree being both _1 and the root node.

Thus, <code>parent_cover</code> propagates coverage to parent nodes based on the weighted average of coverage at the children.

 

 

NAME_HIERARCHY │WEIGHT │COVERAGE │

cleaning │ 1 │0.409167 │

cellars │ 1 │ 1 │

wine_cellar │ 1 │ 1 │

 

Extra credit:

 

power=: */@:{&(parent (] % (i.~ ~.)@[ { +//.) weight)@> trace

 

power*1-weight parent_cover coverage

 

Explanation:

 

And, <code>weight parent_cover coverage</code> was the functional coverage for each node.

 

=={{header|Julia}}==

Most implementations of functional coverage are going to store values in a database. The implementation

stores the tree in a CSV file with an index to the parent of each entry to allow reconstitution of the tree.

 

function updatecoverage(dfname, outputname)

println("\nUpdated data:")

displaycoveragedb(newdbname)

<pre>

Input data:

 

=={{header|Kotlin}}==

 

class FCNode(val name: String, val weight: Int = 1, coverage: Double = 0.0) {

println("${"%8.6f".format(diff)} to ${"%8.6f".format(topCoverage + diff)}")

h2Basement[2].coverage = 0.75 // restore to original value if required

 

{{out}}

the top level coverage would increase by 0.016667 to 0.425833

</pre>

 

 

use warnings;

 

 

}

 

__DATA__

wine_cellar | |1 |

cinema | |0.75 |

{{out}}

bedrooms |1 |0.25 |

bathrooms |1 |0.5 |

garage |1 |0 |

garden |1 |0.8 |

upstairs |1 |0.15 |

bedrooms |1 |0 |

toilet |1 |0 |

attics |1 |0.6 |

kitchen |1 |0 |

living_rooms |1 |0 |

garden |1 |0.9 |

hot_tub_suite |1 |1 |

cellars |1 |1 |

wine_cellar |1 |1 |

</pre>

=={{header|Python}}==

===Python: Using lists and tuples===

It's actually some of the raw code used when researching this task.

 

 

 

print('\n\nTOP COVERAGE = %f\n' % covercalc(lstc))

depth_first(lstc)

 

{{out}}

A cleaner implementation that uses the class static variable path2node as in the previous example so you don't have to traverse the tree to work out the position to add new nodes. This relies on parent nodes appearing before their children which is the case in the order of the add_node calls.

 

 

SPACES = 4

assert isclose((delta + cover), 1.0), "Top level delta + coverage should " \

"equal 1 instead of (%f + %f)" % (delta, cover)

 

{{out}}

Mainly uses pre-existing generic functions, including '''forestFromLineIndents''', '''foldTree''' and '''fmapTree''':

{{Works with|Python|3.7}}

 

from itertools import chain, product

from functools import reduce

 

 

delimiter = '|'

 

columnTitles = init(columnNames(delimiter)(reportLines[0]))

 

print(titleLine(delimiter)(columnWidths)(

columnTitles + ['share of residue']

print(indentedLinesFromTree(' ', tabulation(columnWidths))(

 

withResidueShares(1.0)(

 

fmapTree(

)(

)

)

 

 

 

# [Tree Dict] -> Tree Dict

as a function of the weighted averages

of its children.

'''

def go(xs):

return Node(dict(

x, **{

}

))(xs)

 

 

'''

def go(fraction, node):

weights = [root(x)['weight'] for x in nodeNest]

siblingsTotal = sum(weights)

 

 

 

# tabulation :: [Int] -> String -> Dict -> String

 

 

 

# Node :: a -> [Tree a] -> Tree a

 

 

'''The application of each of a list of functions,

to each of a list of values.

'''

 

 

# concatMap :: (a -> [b]) -> [a] -> [b]

def concatMap(f):

'''

 

 

 

 

'''

 

 

def fmapTree(f):

'''A new tree holding the results of

the existing tree.

'''

def go(x):

 

 

def foldTree(f):

'''The catamorphism on trees. A summary

'''

def go(node):

])

 

 

with integers giving their levels of indentation.

'''

def go(xs):

if xs:

)(xs[1:])

else:

return []

'''First member of a pair.'''

return tpl[0]

 

 

giving its level of indentation from 0 upwards.

'''

indentTextPairs = list(map(

xs

))

)(indentTextPairs))

return list(map(

indentTextPairs

))

'''

def go(indent):

 

 

 

 

'''

 

 

span p xs is equivalent to (takeWhile p xs, dropWhile p xs).

'''

def go(xs):

 

 

# splitOn :: String -> String -> [String]

def splitOn(pat):

xs.split(pat) if isinstance(xs, str) else None

)

 

 

'''String in lower case.'''

return s.lower()

 

 

The initial seed value is x.

'''

 

 

wine_cellar | |1 |

cinema | |0.75 |'''

{{Out}}

<pre>NAME_HIERARCHY | WEIGHT | COVERAGE | SHARE OF RESIDUE

(in this case <code>data/functional-coverage.txt</code>).

 

(require racket/list racket/string racket/match racket/format racket/file)

 

(for-each

(compose print-coverage-tree find-wght-cvrg)

 

{{out}}

| wine_cellar | 1 | 1.00 | 1.00000 |

| cinema | 1 | 0.75 | 0.75000 |</pre>