Python Table.latex方法代码示例

# 需要导入模块: from table import Table [as 别名]
# 或者: from table.Table import latex [as 别名]
 def gen_ctx():
     ctx = Chi2GoodnessOfFitData(seed = seed) 
 
     #Here we sample from a non-uniform distribution for the die!
     ctx1_args = {
         'o_dist':[1/5, 1/5, 1/5, 1/5, 1/10, 1/10],
         'alternative':"The die is not fair.",
         'note':"""
             For this problem the truth is tha the die is not fair. \
             If you accepted H<sub>0</sub>, then this is a <strong>miss</strong>
             (Type II error).
             """
     }
     
     ctx1 = Chi2GoodnessOfFitData(seed = seed, **ctx1_args)
     
             
     ######################################
     # Pass the pigs game: Due to embedding the table in the story
     # this one is a little harder to set up. The problem is that this 
     # pollutes namespace for future contexts. 
     
      
     # Append _ to avoid namespace pollution
     _outcomes =  ['Pink', 'Dot', 'Razorback', 'Trotter', 
                  'Snouter', 'Leaning Jowler']
     _t_dist = [.35, .30, .20, .10, .04, .01]
     tb = Table(_t_dist, col_headers = _outcomes, 
                row_headers = ['Position', 'Expected Frequency'])
     
     if fmt == 'html':
         styles = Table.get_style()
         tbl = tb.html()
     else:
         styles = ""
         tbl = tb.latex()
     
     _s_size = random.randint(20, 30) * 10
     
     ctx2_args = {
         'outcome_type':'Position',
         'outcomes':_outcomes,
         't_dist':_t_dist,
         's_size':_s_size,
         'story':"""Pass The Pigs&reg; is a game from Milton-Bradley&#8482; 
             which is essentially a dice game, except that instead of dice 
             players toss small plastic pigs that can land in any of 6 
             positions. For example, you roll a 'trotter' if the pig falls 
             standing on all 4 legs. It is claimed that the distribution
             for the 6 positions are:
             
             {styles}
             {tbl}            
             
             To test this you toss a pig {s_size} times and get the observed 
             frequencies below:
             """.format(styles = styles, tbl = tbl, s_size = _s_size),
         'null':"The observed values of the positions of the pigs agrees \
         with the expected distribution.",
         'alternative':"The observed values of the positions of the pigs \
         differs from what should be the case if the expected distribution\
         was correct.",
         'note':"""
             In this case the observed data was sampled from the given
             distribution. So if the null hypothesis is rejected, this
             is <string>a Type-I error</strong> or <strong>a false 
             positive</strong>.
             """
     }
     
     ctx2 = Chi2GoodnessOfFitData(seed = seed, **ctx2_args)
     
    
         
     ###########################################
     ## 11.2 from text
     s_size = random.randint(5, 10) * 10
     ctx3_args = {
         'outcomes':['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday',
                 'Friday', 'Saturday'],
         't_dist':np.ones(7) * 1/7,
         's_size':s_size,
         'a_level': random.choice([0.1,0.01,0.05]),
         'outcome_type':'Day of Week',
         'story':"""
               Teachers want to know which night each week their students are 
               doing most of their homework. Most teachers think that students 
               do homework equally throughout the week. Suppose a random sample 
               of %s students were asked on which night of the week they 
               did the most homework. The results were distributed as in  
               """ % s_size,
         'null':"Students are equally likely to do the majority of their \
         homework on any of the seven nights of the week.",
         'alternative':"Students are more likely to do the majority of their \
         homework on certain nights rather than others."
     }
         
     ctx3 = Chi2GoodnessOfFitData(seed = seed, **ctx3_args)
         
     return [ctx, ctx1, ctx2, ctx3]

# 需要导入模块: from table import Table [as 别名]
# 或者: from table.Table import latex [as 别名]
 def explanation(self, path = 'explanations', 
             expanded = True, a_type = 'preview',                     
             force = False, xkcd = False, fmt = 'latex'):
     """
     Provides an explanation of the hyperbola.
 
     Parameters: (Largely shared with show)
     -----------
     path      : str
         The output directory for image files
     file_name : str
         The name of output file without extension.
     a_type   : Strint ('MC', 'preview')
         If 'preview', then set up for previewing.
     fmt       : String ('html', 'latex')
         If 'latex' us MathJax, if 'html' use CSS tables.
     """
     
     if fmt == 'html':
         ex = Table.get_style()
     else:
         ex = ""
 
 
     file_name = path + "/" + self.url + ".png"
 
     if a_type == 'preview':
         file_name = file_name.replace('%2','%252')
 
 
     const = self.a ** 2 * self.b **2
     x_part = const*(self(x, self.k).expand() - self(0, self.k))
     y_part = const*(self(self.h, y).expand() - self(self.h, 0))
     rhs = const - const*self(0, 0)
 
     # The following is an attempt to avoid lots of code duplication.
     if self.trans == 'x':
         X = x
         Y = y
         X_part = x_part
         Y_part = y_part
         HH = self.h
         KK = self.k
         TX = 1
         TY = 0
     else:
         X = y
         Y = x
         X_part = y_part
         Y_part = x_part
         HH = self.k
         KK = self.h
         TX = 0
         TY = 1
     # To reduce typing
     A = self.a
     B = self.b
     H = self.h
     K = self.k
     C = self.c 
 
     k, h, a, b, c = sym.symbols('k h a b c')
 
     gcd_X = sym.gcd(X_part.collect(X).coeff(X,1), X_part.collect(X).coeff(X,2))
     gcd_Y = sym.gcd(Y_part.collect(Y).coeff(Y,1), Y_part.collect(Y).coeff(Y,2))
     b_X = X_part.collect(X).coeff(X,1)/gcd_X
     b_Y = -Y_part.collect(Y).coeff(Y,1)/gcd_Y        
 
     if expanded:
         ex += "The first step to finding the graph of $$%s = 0$$ is\
             to find the normal form of the equation." \
         % sym.latex((const*(self(x, y) - 1)).expand())
 
         ex += " To begin move the constant term to the right hand side. \
             This gives: $$(%s) + (%s) = %s$$" \
                 % (sym.latex(x_part), sym.latex(y_part), rhs)
 
 
 
         ex += "Next factor common factors from the $_x$_ and $_y$_ terms to get: \
             $$%s(%s) - %s(%s) = %s$$" \
         % (gcd_X if gcd_X != 1 else "", sym.latex(X_part/gcd_X), 
            gcd_Y if gcd_Y != 1 else "", sym.latex(-Y_part/gcd_Y), rhs)
 
         ex += "Now complete the squares: \
             $$%s\\left(%s  %s\\right) \
             - %s\\left(%s  %s\\right) = \
             %s %s %s$$"\
              % (gcd_X if gcd_X != 1 else "", sym.latex(X_part/gcd_X), 
                 "+ \\left(\\frac{%s}{2}\\right)^2" % b_X if b_X != 0 else "", 
                 gcd_Y if gcd_Y != 1 else "", sym.latex(-Y_part/gcd_Y), 
                 "+ \\left(\\frac{%s}{2}\\right)^2" % b_Y if b_Y != 0 else "", 
                 rhs, 
                 "+ %s\\left(\\frac{%s}{2}\\right)^2" % (gcd_X, b_X) if b_X != 0 else "", 
                 "- %s\\left(\\frac{%s}{2}\\right)^2" % (gcd_Y, b_Y) if b_Y != 0 else "")
 
         ex += "This simplifies to: $$%s\\left(%s\\right)^2 - %s\\left(%s\\right)^2 = %s$$" \
             % (gcd_X if gcd_X != 1 else "",
                sym.latex(X + b_X/2),
                gcd_Y if gcd_Y != 1 else "",
#.........这里部分代码省略.........

# 需要导入模块: from table import Table [as 别名]
# 或者: from table.Table import latex [as 别名]
    def stem(self, context = None, table = None, q_type = None,
             a_type = 'preview', force = False, fmt = 'html'):
        """
        This will generate a problem for $\chi^2$ goodness of fit.
        
        Parameters:
        ----------
        context : context object
            This describes the problem. A default context is used if this is 
            none.
        table   : string ['hist', 'table'] 
            Display t_dist as a table (html/latex) or as a histogram.
        q_type  : string [None, 'STAT', 'HT', 'CI'] 
            If None randomly choose. If 'STAT' just compute the chi2 statistic 
            and the degrees of freedom. If 'HT, compute the p-value for the  
            data and determine whether or not reject the null hypothesis. If 
            'CI' compute the confidence interval.
        a_type  : string
            This is eithe "MC" or "preview" for now
        fmt   : String ['html', 'latex']
            Use nice CSS/HTML (responsive) or plain LaTeX (static)
        
        Notes:
        -----
        The default here is to simulate a roll of a die 30 times and record the
        frequency of values. The :math`\chi^2` test should test whether the die
        is fair at an :math:`alpha` 
        level of 5%.
        """
        
        kwargs = {
            'context': context,
            'table': table,
            'q_type': q_type,
            'fmt': fmt,
            'a_type': a_type
        }
        
        if q_type is None:
            q_type = random.choice(['STAT', 'HT', 'PVAL'])
          

        if table == None:
            table = random.choice(['table', 'hist'])
        
        if context == None:
            context = Chi2GoodnessOfFitData()
            
        if not context.is_valid:
            warnings.warn("Context had invalid cell counts.")
            return       
        
        # Generate unique name
        q_name = hash(context)
        self.cache.add(q_name)
        self.hist = str(q_name) + "_hist.png"
        self.solution_plot = str(q_name) + "_plot.png"
        
        style = None
            
        
        if a_type == 'preview':
                question_stem = "<h2>Question</h2><br>"
        else:
            question_stem = ""

        if fmt == 'html':
            question_stem += Table.get_style()
        
        question_stem += "<div class='par'>" + context.story + "</div>\n" 
        if table == 'table':
            if fmt == 'html':
                tbl = context.observed.html()
                question_stem += tbl
            else:
                tbl = context.observed.latex()
                question_stem +=  tbl
            
        elif table == 'hist':
            
            fname = context.hist(path = self.path, force = force)
                                  
            img = html_image(fname, width = '300px', 
                             preview = (a_type == 'preview'))
            
            
            if style is None:
                style = Table.get_style()
                question_stem += style
            
            question_stem +="""      
            <div class='outer-container-rk'>
                <div class='centering-rk'>
                    <div class='container-rk'>
                        <figure>
                            %s
                            <figcaption>%s</figcaption>
                        </figure>
                    </div>
                </div>
#.........这里部分代码省略.........