Beispiel #1
0
def test_2_curves_v2():
    p = Plotter(-1, 1, width=50, symbols='sc')
    from math import sin, cos, pi
    from numpy import linspace
    tp = linspace(0, 6 * pi, 6 * 8 + 1)
    s = ''
    for t in tp:
        s += '%s\n' % (p.plot(t, sin(t), cos(t)))
    ans = dd("""\
                         |                        c
                         |         s            c  
                         |                 c       
                         |         c            s  
                         |                        s
               c         |                      s  
       c                 |                 s       
  c                      |         s               
c                        |                         
  c            s         |                         
       c                 |                         
  s            c         |                         
s                        |                         
  s                      |         c               
       s                 |                 c       
               s         |                      c  
                         |                        c
                         |         s            c  
                         |                 c       
                         |         c            s  
                         |                        s
               c         |                      s  
       c                 |                 s       
  c                      |         s               
c                        |                         
  c            s         |                         
       c                 |                         
  s            c         |                         
s                        |                         
  s                      |         c               
       s                 |                 c       
               s         |                      c  
                         |                        c
                         |         s            c  
                         |                 c       
                         |         c            s  
                         |                        s
               c         |                      s  
       c                 |                 s       
  c                      |         s               
c                        |                         
  c            s         |                         
       c                 |                         
  s            c         |                         
s                        |                         
  s                      |         c               
       s                 |                 c       
               s         |                      c  
                         |                        c
""")
    assert ans == s
Beispiel #2
0
 def __str__(self):
     ctx = dict(
         var=self.var,
         iter=self.iter,
         body=iblock(4, str(self.body)),
     )
     return dd(self.__doc__).format(**ctx)
Beispiel #3
0
    def compile_data(self, comments: bool, errors: bool) -> str:
        """Return a formatted string of data points.

        Args:
            comments: Flag to control the output of comments.
            errors: Flag to control the output of errors.
        """
        # Compile cook data and stage info header.
        output = '\n'.join((
            ('\n' + f"File: {self.NAME}".center(79)),
            (self._wrapper("[Cook Info]")),
            (dd(f"""
            Product: {self.PRODUCT}
            Lot: {self.LOT}
            Oven: {self.OVEN}
            Program {self.PROGRAM}
            Start: {self.START_TIME}
            Starting Temps: {self.START_TEMPS}
            End: {self.END_TIME}
            Ending Temps: {self.END_TEMPS}
            Duration: {self.DURATION} minutes [{self._to_hours(self.DURATION)}]
            In-weight: {self._check_val(self.IN_WEIGHT)}
            Out-weight: {self._check_val(self.OUT_WEIGHT)}
            Yield: {self._check_val(self.COOK_YIELD)} \
            """)),
            (self._wrapper("[Stage Info]", '=')),
            ('')  # Add a blank space between 'Stage Info' header and data
        ))
        # Compile stage data.
        for stage, duration in self.STAGES.items():
            output += f"\n{stage}: {int(duration)} minutes"
        # TODO Implement comments and error output
        return output + '\n'
Beispiel #4
0
 def __str__(self):
     ctx = dict(
         var  = self.var,
         iter = self.iter,
         body = iblock(4, str(self.body)),
     )
     return dd(self.__doc__).format(**ctx)
Beispiel #5
0
def fmt_msgs(msgs):
    """
    Handles lines and indentation!

        cli.echo(
           '''
              line
                 indented
           ''',
           'inline',
           '   inline indented',
           '''
           different indent
           '''
        )

    Output:
        line
              indented

        inline
           inline indented

        different indent
    """
    return str.strip(dd("\n".join(map(fmt, msgs))))
Beispiel #6
0
def calc(expresión=0, precisión=1000):
    '''
    Calculadora de expresiones con números complejos.

    expresión: expresión númerica válida.
    precisión: precisión de la simplificación.

    Uso:
    >>> from calc_comp import calc
    >>> from numpy import conjugate as c
    >>> z1 =  3-2j
    >>> z2 = -5-6j
    >>> z3 = -4+2j
    >>> exp = ((z1 - c(z2)) / z2) * ((2*z1) / z3)
    >>> calc(exp)
    (-0.49836065573770494-2.281967213114754j) =
         -152             -696
    ------------- + ------------- i
         305             305
    '''
    z = expresión
    frac_real = F.from_float(z.real).limit_denominator(precisión)
    frac_imag = F.from_float(z.imag).limit_denominator(precisión)
    print(dd('''\
             {0} =
                  {1}             {2}
             ------------- + ------------- i
                  {3}             {4}'''.format(expresión,
                                                frac_real.numerator,
                                                frac_imag.numerator,
                                                frac_real.denominator,
                                                frac_imag.denominator)))
Beispiel #7
0
def main():
    """
    The main function that accepts and sanitize the input options from the
    user and then calls the check function
    """
    banner = dd("""\
                ===============================
                    Log Miner (version 1.1)
                ===============================""")
    print(banner)

    parser = optparse.OptionParser("%prog -s <search string> -i <input-file>"
                                   " -o <output file> -v <1 verbose, 0 silent>")

    parser.add_option('-i', dest='inputFile',
                            type='string',
                            help='specify File to open (/var/log/syslog)')

    parser.add_option('-s', dest='stringx',
                            type='string',
                            help='specify string to search')

    parser.add_option('-o', dest='outputFile',
                            type='string',
                            help='specify output file (optional)')

    parser.add_option('-v', dest='verbosity',
                            type='int',
                            help='1 for verbose, 0 for silent (optional)')

    options, args = parser.parse_args()

    inputFile = options.inputFile
    stringx = options.stringx
    outputFile = options.outputFile
    screen = options.verbosity

    if not inputFile:
        inputFile = "/var/log/syslog" # doesn't work with systemd
    print("[+] Loading.. %s" % inputFile)

    if not outputFile:
        outputFile = "data/dump.log"

    if not stringx:
        print("[-] Nothing to do! Use -h or --help for help")
        exit(0)

    try:
        # ensures files are closed allways! even if exceptions are raised
        with open(inputFile) as inFile: # 'r' is default
            with open(outputFile, 'a') as outFile:
                if screen:
                    miner(stringx, inFile, outFile, screen=screen)
                else:
                    miner(stringx, inFile, outFile)
    except IOError as e:
        # print to standard error stream
        print('[!] ERROR: {0}'.format(e), file=sys.stderr)
Beispiel #8
0
 def __str__(self):
     ctx = dict(
         name=self.name,
         args=', '.join(str(arg) for arg in self.args),
         ret=self.ret,
         body=iblock(4, str(self.body)),
     )
     return dd(self.__doc__).format(**ctx)
Beispiel #9
0
 def __str__(self):
     ctx = dict(
         name = self.name,
         args = ', '.join(str(arg) for arg in self.args),
         ret  = self.ret,
         body = iblock(4, str(self.body)),
     )
     return dd(self.__doc__).format(**ctx)
Beispiel #10
0
    def _wrapper(self, header: str, border: str = '=') -> str:
        """Return a centered header, wrapped with a border.

        Args:
            header: The header to wrap.
            border: The border symbol to wrap the header with.
        """
        wrap = border * 79
        return dd(f"""
        {wrap}
        {header.center(79)}
        {wrap}""")
Beispiel #11
0
def banner():
    print(dd(
        r"""
           _____  ________  ___________.___  _________
          /  _  \ \______ \ \_   _____/|   |/   _____/
         /  /_\  \ |    |  \ |    __)  |   |\_____  \
        /    |    \|    `   \|     \   |   |/        \
        \____|__  /_______  /\___  /   |___/_______  /
                \/        \/     \/                \/

        May the "Donut Fairy" NOT be with you!

        """
    ))
Beispiel #12
0
def main():
    # prompt = chr(10144)   # cmd.exe es tan patetico...
    while True:
        clear()
        cadena_in = input(dd('''\
                             Escriba una expresion para numeros flotantes,
                             su validez sera evaluada: (S/SALIR, para finalizar)
                             => '''.format_map(vars())))
        if cadena_in.lower() in ['s', 'salir']:
            sys.exit()
        else:
            prueba = primera_validacion(cadena_in)
            if prueba:
                segunda_validacion(prueba)
            input('\nPresione ENTER para continuar.')
def main(entero='1337', dec='007'):
    n = Numero(entero, dec)
    nd = n.a_float()
    n2 = n.a_base(2)
    n8 = n.a_base(8)
    n10 = n.a_base(10)
    n16 = n.a_base(16)

    print(dd('''
                Number:\t\t{0}
                Float:\t\t{1}
                Binario:\t{2}
                Octal:\t\t{3}
                Decimal:\t{4}
                Hexadecimal:\t{5}'''.format(n, nd, n2, n8, n10, n16)))
Beispiel #14
0
def primera_validacion(cadena):
    if cadena.lower() in ['inf', 'infinity', 'nan']:
        return cadena
    coincidencia = patron.search(cadena)
    if coincidencia:
        _coincidencia = coincidencia.groups()
        print(dd('''
                 coincidencia: {_coincidencia}

                 signo     : {_coincidencia[0]}
                 entero    : {_coincidencia[1]}
                 punto     : {_coincidencia[2]}
                 decimal   : {_coincidencia[3]}
                 marca_exp : {_coincidencia[4]}
                 signo_exp : {_coincidencia[5]}
                 exponente : {_coincidencia[6]}
                 '''.format_map(vars())))
        return coincidencia.group()
    else:
        print(eval(error))
Beispiel #15
0
def _demo():
    from numpy import linspace, exp, sin, pi
    x = linspace(-2, 2, 31)
    y = exp(-0.5 * x ** 2) * sin(2 * pi * x)
    data = dd("""
    from numpy import linspace, exp, sin, pi
    x = linspace(-2, 2, 31)
    y = exp(-0.5*x**2)*sin(2*pi*x)
    """)
    cmd = ["plot(x, y)",
           "plot(x, y, draw_axes=False)",
           "plot(x, y, plot_slope=False)",
           "plot(x, y, plot_labels=False)",
           "plot(x, y, dot='o', plot_slope=False)",
           "p = plot(x, y, output=str)",
           "print(p)"
           ]
    print(data)
    for c in cmd:
        print('\n\n', c)
        exec(c)
Beispiel #16
0
    def run_yosys(self) -> bool:
        run_script = os.path.join(self.run_dir, "run.sh")
        makefile = self.openroad_flow_makefile_path()
        design_config = self.design_config_path()
        synth_script = self.synth_script_path()

        self.validate_openroad_installation()
        self.setup_openroad_rundir()
        self.create_design_config()

        with open(run_script, "w") as f:
            f.write(
                dd("""\
              #!/bin/bash
              cd "{rundir}"
              mkdir -p results/{tech}/{name}
              make DESIGN_CONFIG={conf} SYNTH_SCRIPT={script} -f {make} synth\
            """.format(rundir=self.run_dir,
                       tech=self.get_setting("vlsi.core.technology"),
                       name=self.top_module,
                       conf=design_config,
                       script=synth_script,
                       make=makefile)))
        os.chmod(run_script, 0o755)

        if bool(self.get_setting("synthesis.yosys.generate_only")):
            self.logger.info("Generate-only mode: command-line is " + \
                             " ".join(args))
        else:
            # Temporarily disable colors/tag to make run output more readable
            # TODO: think of a more elegant way to do this?
            HammerVLSILogging.enable_colour = False
            HammerVLSILogging.enable_tag = False
            self.run_executable([run_script])  # TODO: check for errors
            HammerVLSILogging.enable_colour = True
            HammerVLSILogging.enable_tag = True

        return True
Beispiel #17
0
    def run_openroad(self) -> bool:
        run_script = os.path.join(self.run_dir, "par.sh")

        self.validate_openroad_installation()
        self.setup_openroad_rundir()

        with open(run_script, "w") as f:
            f.write(
                dd("""\
              #!/bin/bash
              cd "{rundir}"
              mkdir -p logs/{tech}/{name}
              mkdir -p objects/{tech}/{name}
              mkdir -p reports/{tech}/{name}
              mkdir -p results/{tech}/{name}
            """.format(
                    rundir=self.run_dir,
                    tech=self.get_setting("vlsi.core.technology"),
                    name=self.top_module,
                )))
            f.write("\n".join(self.cmds))
        os.chmod(run_script, 0o755)

        if bool(self.get_setting("par.openroad.generate_only")):
            self.logger.info("Generate-only mode: command-line is " + \
                             " ".join(args))
        else:
            # Temporarily disable colors/tag to make run output more readable
            # TODO: think of a more elegant way to do this?
            HammerVLSILogging.enable_colour = False
            HammerVLSILogging.enable_tag = False
            self.run_executable([run_script])  # TODO: check for errors
            HammerVLSILogging.enable_colour = True
            HammerVLSILogging.enable_tag = True

        return True
Beispiel #18
0
from functools import reduce
from textwrap import dedent as dd
from timeit import repeat

sources = ["canada", "citm_catalog", "citylots", "twitter"]

min_times = []
for source in sources:
    s = dd(f"""\
    with open("../data/{source}.json") as f:
        json.load(f)""")
    times = repeat(stmt=s, setup="import json", repeat=3, number=1)
    t = reduce(min, times)
    print(f"{source} {t:0.06f} seconds")
    min_times.append(t)

geo_mean = reduce(lambda a, b: a * b, min_times)**(1 / len(min_times))
print(f"Total (G.M): {geo_mean:0.06f}")
Beispiel #19
0
 def __str__(self):
     return dd(self.__doc__) % (self.name, self.ty)
     'Touch'),
     ('Height', 'Weight'),
     ('Physique',)
)

# TODO: Figure out how to determine chosen race and give stat info
# http://cloud-3.steamusercontent.com/ugc/320124788920141475/83A5568F35B91FC2BD926876D7757487797911CF/

extra_info = {
    'Intelligence': dd(
        '''
        Intelligence primarily affects how quickly you train skills.

        The following skills are governed by this stat:
        Agriculture,
        Building,
        Herblore,
        Physician,
        Ritual,
        Trapping,
        Weatherlore
        '''
    ),

    'Will': dd(
        '''
        Will affects your ability to stay awake when exhausted and your abiliity
        to force yourself to eat raw meat and fish (and then throwing up).

        The following skills are governed by this stat:
        Agriculture,
        Fishing,
Beispiel #21
0
def main():
    """
    The main function that accepts and sanitize the input options from the
    user and then calls the check function
    """
    banner = dd("""\
                ===============================
                    Log Miner (version 1.1)
                ===============================""")
    print(banner)

    parser = optparse.OptionParser(
        "%prog -s <search string> -i <input-file>"
        " -o <output file> -v <1 verbose, 0 silent>")

    parser.add_option('-i',
                      dest='inputFile',
                      type='string',
                      help='specify File to open (/var/log/syslog)')

    parser.add_option('-s',
                      dest='stringx',
                      type='string',
                      help='specify string to search')

    parser.add_option('-o',
                      dest='outputFile',
                      type='string',
                      help='specify output file (optional)')

    parser.add_option('-v',
                      dest='verbosity',
                      type='int',
                      help='1 for verbose, 0 for silent (optional)')

    options, args = parser.parse_args()

    inputFile = options.inputFile
    stringx = options.stringx
    outputFile = options.outputFile
    screen = options.verbosity

    if not inputFile:
        inputFile = "/var/log/syslog"  # doesn't work with systemd
    print("[+] Loading.. %s" % inputFile)

    if not outputFile:
        outputFile = "data/dump.log"

    if not stringx:
        print("[-] Nothing to do! Use -h or --help for help")
        exit(0)

    try:
        # ensures files are closed allways! even if exceptions are raised
        with open(inputFile) as inFile:  # 'r' is default
            with open(outputFile, 'a') as outFile:
                if screen:
                    miner(stringx, inFile, outFile, screen=screen)
                else:
                    miner(stringx, inFile, outFile)
    except IOError as e:
        # print to standard error stream
        print('[!] ERROR: {0}'.format(e), file=sys.stderr)
Beispiel #22
0
 def __str__(self):
     if self.val == None:
         return "var %s %s" % (self.ty, self.name)
     else:
         return dd(self.__doc__) % (self.ty, self.name, self.val)
Beispiel #23
0
 def __str__(self):
     return dd(self.__doc__) % self.val
Beispiel #24
0
        port = int(app.config.get('PORT') or options.get('port'))
        app.run(host=host, port=port, debug=debug)
    return app


if __name__ == '__main__':
    import sys
    from textwrap import dedent as dd

    # Catch if local system doesn't have docopt installed
    try:
        from docopt import docopt
    except ImportError as e:
        err_msg = dd('''
        ERROR: Docopt is not installed.  Please install to proceed.

            > pip install docopt
        ''')
        print(err_msg, file=sys.stderr)
        sys.exit()

    options = {k.lstrip('--'): v for k, v in docopt(__doc__).items()}
    config_mapping = {
        'dev': DevConfig,
        'demo': DemoConfig,
        'local': LocalDemoConfig
    }
    options['config'] = config_mapping.get(options['config'], DemoConfig)
    options['_run_'] = True
    main(**options)
Beispiel #25
0
 def __str__(self):
     return dd(self.__doc__) % (self.target, self.value)
Beispiel #26
0
def test_2_curves_v1():
    p_sin = Plotter(-1, 1, width=25, symbols='s')
    p_cos = Plotter(-1, 1, width=25, symbols='c')
    from math import sin, cos, pi
    from numpy import linspace
    tp = linspace(0, 6 * pi, 6 * 8 + 1)
    s = ''
    for t in tp:
        s += '%s %s\n' % (p_sin.plot(t, sin(t)), p_cos.plot(t, cos(t)))
    ans = dd("""\
            |                          |            c
            |    s                     |           c 
            |        s                 |        c    
            |           s              |    c        
            |            s             |             
            |           s          c   |             
            |        s         c       |             
            |    s          c          |             
            |s             c           |             
        s   |               c          |             
    s       |                  c       |             
 s          |                      c   |             
s           |                          |             
 s          |                          |    c        
    s       |                          |        c    
        s   |                          |           c 
            |                          |            c
            |    s                     |           c 
            |        s                 |        c    
            |           s              |    c        
            |            s             |c            
            |           s          c   |             
            |        s         c       |             
            |    s          c          |             
            |s             c           |             
        s   |               c          |             
    s       |                  c       |             
 s          |                      c   |             
s           |                          |             
 s          |                          |    c        
    s       |                          |        c    
        s   |                          |           c 
            |                          |            c
            |    s                     |           c 
            |        s                 |        c    
            |           s              |    c        
            |            s             |c            
            |           s          c   |             
            |        s         c       |             
            |    s          c          |             
            |s             c           |             
        s   |               c          |             
    s       |                  c       |             
 s          |                      c   |             
s           |                          |             
 s          |                          |    c        
    s       |                          |        c    
        s   |                          |           c 
            |                          |            c
""")
    assert ans == s
Beispiel #27
0
 def __str__(self):
     return dd(self.__doc__) % (self.inf, self.sup)
Beispiel #28
0
 def __str__(self):
     if self.val == None:
         return "var %s %s" % (self.ty, self.name)
     else:
         return dd(self.__doc__) % (self.ty, self.name, self.val)
Beispiel #29
0
 def __str__(self):
     return dd(self.__doc__) % (self.name, self.ty)
"""
import optparse
from textwrap import dedent as dd
import logging
import subprocess

logging.basicConfig(level=logging.DEBUG)

op = optparse.OptionParser()
op.add_option('-i', dest='infile', help='Input GFF file.')
op.add_option('-o', dest='outfile',
              help='Output GFF file, suitable for use with TopHat')
op.add_option('--index', 
              dest='index',
              help=dd('''
                   index name for Bowtie index. 
                   bowtie-inspect and the index 
                   must be on your path.'''))
op.add_option('--no-auto-chr',dest='noautochr',
              default=False,
              action='store_true',
              help="""Disable automatic prepending of "chr" to output file
              chromosome names if not already present.""")
options,args = op.parse_args()

p = subprocess.Popen('bowtie-inspect --names %s' % options.index, 
                     shell=True, stdout=subprocess.PIPE)
chroms = p.communicate()[0]
chroms = chroms.split('\n')
chroms = [i for i in chroms if len(i) > 0]
logging.debug('chromosomes found in bowtie index %s were \n\t%s' \
                % (options.index, '\n\t'.join(chroms)))
Beispiel #31
0
def test_sin():
    a = 0.2
    p = Plotter(-1 - a, 1 + a, width=50)
    from math import sin, pi
    from numpy import linspace
    num_periods = 2
    resolution_per_period = 22
    s = ''
    tp = linspace(0, num_periods * 2 * pi,
                  num_periods * resolution_per_period + 1)
    for t in tp:
        y = (1 + a * sin(0.5 * t)) * sin(t)
        s += 't=%5.2f %s %5.2f\n' % (t, p.plot(t, y), y)

    ans = dd("""\
t= 0.00                          |                           0.00
t= 0.29                          |     *                     0.29
t= 0.57                          |           *               0.57
t= 0.86                          |                *          0.82
t= 1.14                          |                    *      1.01
t= 1.43                          |                      *    1.12
t= 1.71                          |                       *   1.14
t= 2.00                          |                     *     1.06
t= 2.28                          |                  *        0.89
t= 2.57                          |            *              0.64
t= 2.86                          |      *                    0.34
t= 3.14                          |                           0.00
t= 3.43                   *      |                          -0.34
t= 3.71             *            |                          -0.64
t= 4.00       *                  |                          -0.89
t= 4.28    *                     |                          -1.06
t= 4.57  *                       |                          -1.14
t= 4.86   *                      |                          -1.12
t= 5.14     *                    |                          -1.01
t= 5.43         *                |                          -0.82
t= 5.71              *           |                          -0.57
t= 6.00                    *     |                          -0.29
t= 6.28                          |                          -0.00
t= 6.57                          |     *                     0.27
t= 6.85                          |          *                0.51
t= 7.14                          |             *             0.69
t= 7.43                          |                *          0.81
t= 7.71                          |                 *         0.86
t= 8.00                          |                 *         0.84
t= 8.28                          |               *           0.76
t= 8.57                          |            *              0.62
t= 8.85                          |        *                  0.44
t= 9.14                          |    *                      0.23
t= 9.42                          |                           0.00
t= 9.71                     *    |                          -0.23
t=10.00                 *        |                          -0.44
t=10.28             *            |                          -0.62
t=10.57          *               |                          -0.76
t=10.85        *                 |                          -0.84
t=11.14        *                 |                          -0.86
t=11.42         *                |                          -0.81
t=11.71            *             |                          -0.69
t=12.00               *          |                          -0.51
t=12.28                    *     |                          -0.27
t=12.57                          |                          -0.00
""")
    assert ans == s
Beispiel #32
0
 def __str__(self):
     return dd(self.__doc__) % (self.inf, self.sup)
Beispiel #33
0
 def __str__(self):
     return dd(self.__doc__) % (self.target, self.value)
Beispiel #34
0
    def create_design_config(self) -> bool:
        """
        the design-config is the main configuration for the OpenROAD built-in
        scripts. initially, we are using OpenROAD's tool scripts as-is, so
        we need to create a design-config that their scripts understand. the
        synthesis tool is the only tool that will write this
        """
        design_config = self.design_config_path()

        # Load input files and check that they are all Verilog.
        if not self.check_input_files([".v", ".sv"]):
            return False
        abspath_input_files = list(
            map(lambda name: os.path.join(os.getcwd(), name),
                self.input_files))

        # Add any verilog_synth wrappers (which are needed in some
        # technologies e.g. for SRAMs) which need to be synthesized.
        abspath_input_files += self.technology.read_libs(
            [hammer_tech.filters.verilog_synth_filter],
            hammer_tech.HammerTechnologyUtils.to_plain_item)

        # Generate constraints
        input_sdc = os.path.join(self.run_dir, "input.sdc")
        unit = self.get_time_unit().value_prefix + self.get_time_unit().unit
        with open(input_sdc, "w") as f:
            f.write("set_units -time {}\n".format(unit))
            f.write(self.sdc_clock_constraints)
            f.write("\n")
            f.write(self.sdc_pin_constraints)

        # TODO: i am blindly reading in all libs for all corners. but this is
        #       not a performance issue for nangate45
        extra_lefs = list(
            set(
                filter(
                    lambda x: x is not None,
                    map(lambda x: x.library.lef_file,
                        self.technology.get_extra_libraries()))))
        extra_libs = list(
            set(
                filter(
                    lambda x: x is not None,
                    map(lambda x: x.library.nldm_liberty_file,
                        self.technology.get_extra_libraries()))))

        with open(design_config, "w") as f:
            f.write(
                dd("""
            export DESIGN_NICKNAME = {design}
            export DESIGN_NAME     = {design}
            export PLATFORM        = {node}
            export VERILOG_FILES   = {verilogs}
            export SDC_FILE        = {sdc}

            export ADDITIONAL_LEFS = {extra_lefs}
            export ADDITIONAL_LIBS = {extra_libs}

            # These values must be multiples of placement site, which is
            # (x=0.19 y=1.4) for nangate45
            export DIE_AREA    = {die_area}
            export CORE_AREA   = {core_area}

            export CLOCK_PERIOD = {period}

            """.format(
                    design=self.top_module,
                    node=self.get_setting("vlsi.core.technology"),
                    verilogs=" ".join(abspath_input_files),
                    sdc=input_sdc,
                    extra_lefs=" ".join(extra_lefs),
                    extra_libs=" ".join(extra_libs),
                    die_area=self._floorplan_bbox(),
                    core_area=self._floorplan_bbox(),
                    period=self._clock_period_value(),
                )))
        return True
Beispiel #35
0
 def __str__(self):
     return dd(self.__doc__) % self.val