Lingalyzer is a program to assist in analyzing reading time and question answering data gathered using Linger.
Lingalyzer requires a Unix-like command-line (terminal) environment in order to run. On Mac OS X, you can use the Terminal and the tools provided with the Darwin core. On Windows, you should install Cygwin.
Lingalyzer uses the regress and anova programs that come with the |STAT package. It also uses gzip and zcat, which are standard with most Unix distributions. Before using Lingalyzer, make sure those programs are on your path.
You will probably want to create an Analysis directory within your experiment directory and run Lingalyzer from there. Therefore, I will assume that the path to the Results directory, which contains the .dat files, is ../Results. When working with lingalyzer, it is a good idea to store all of the commands in an executable script file, which can be re-run later to reproduce all of the analyses if a subject is dropped or added or the condition file is changed.
There are four files in the Analysis directory. inter1.cnd is the condition file, which you can read about in the next section. raw.lpm and res.lpm are Lingrapher parameter files that help format the graphs produced by Lingrapher.
Finally, analyze is an executable script that contains all of the lingalyzer commands used in the analysis. It is well commented and you should read through it and run the commands as a tutorial. You may want to read the corresponding sections of this guide as you do so to get more information about each type of analysis. When you are ready to analyze your own experiment, you may want to copy the example analysis files and modify them. It will save a lot of time.
The first command line argument to Lingalyzer is a condition file, which normally ends in the extension .cnd. The condition file describes the conditions used in your experiment. A typical condition file might include blocks like these, one for each condition in each experiment that you want to analyze:
set COND_NAME "contrast a" set ANOVA_FACTORS "small white" set GRAPH_LABEL "A) Small White" set REGIONS "1:3-5 2:6 4:7-9" addCondition set COND_NAME "contrast b" set ANOVA_FACTORS "small black" set GRAPH_LABEL "B) Small Black" set REGIONS "1:3-5 2:foo 3:7 4:8-9" addConditionAs of version 1.4, any items for which a condition is not defined in the condition file will be ignored in the analyses (although all conditions except the practice are used in computing word-length regressions). Therefore, you must define all conditions you are interested in, even for the filler items, which normally have condition name "filler -".
It is not unusual to use different condition files for different analyses. If an experiment contains two independent sub-experiments, you could create one condition file that contains all of the conditions and then use filters (like "-f [eq $EXPT E1]") to analyze one at a time. Or, you can create two different condition files, one for each experiment, in which case the filter won't be necessary. You may also want to use multiple condition files to carve up the regions in the sentences in different ways.
The condition file is actually just a piece of Tcl code that will be executed by lingalyzer. The addCondition line actually creates the condition using the values set prior to it. COND_NAME is the name of the condition. It is composed of the name of the experiment followed by a space and the condition name. Remember to enclose the names in quotes or curly braces.
ANOVA_FACTORS are the factor values represented by the condition. For example, imagine that your experiment crosses two factors, color (white or black) and size (small or large). You might have four conditions, the first representing the values "white small", the second "white large", the third "black small", and the fourth "black large". The ANOVA_FACTORS variable is used to indicate which factors correspond to each condition.
GRAPH_LABEL is simply the user-friendly name for the condition that will appear in the legend when Lingrapher is used to generate a graph. It is not actually used by Lingalyzer.
REGIONS defines how the words in the sentences in each condition correspond to regions for analysis. It consists of a list of region specifications. Each region specification has the region number, followed by a colon. Regions should be numbered starting with 1.
After the colon there can be a single word number (2:6) if the region is just one word long, or a range of word numbers (4:7-9) if the region spans multiple words. The first word in the sentence is word 1 (not 0). Alternately, you can use a word tag in place of word numbers (2:foo). The word tag is specified in the Linger items file for the purpose of predefining regions. Region tags should be used if a region spans different words for different sentences in the same condition.
Disjoint regions can be defined using multiple specifications, as in 2:4 3:5 3:7-9 4:10. If you want a region that runs from word 10 to the end of the sentence, however long that may be, just specify a sufficiently large upper bound, as in 6:10-99.
It may be that certain regions do not appear in some conditions. For example, if your sentences involve sentential complements, you might compare reduced and unreduced conditions. Region 3 might be "that" in the unreduced conditions, but absent in the reduced conditions. This is fine.
Any words that are not assigned to a particular region will be considered part of region 0. That is why it is important to start counting the useful regions with 1. It is a good idea to check whether any words fell into region 0 before conducting your other analyses.
If REGION is set to the empty string, {}, the default behavior is to map each word to its own region. Word 1 to region 1, word 2 to region 2, etc.
Because the condition file is just a Tcl script that will be executed after the Lingalyzer code has been run, you can also use it to override any default parameters used by Lingalyzer. These are some of the parameters that might be changed:
# Lingalyzer's verbosity. Increase to help debug errors: set Verbosity 1 # Language encoding of .dat files (same as used in Linger): set LangEncoding iso8859-1 # Experiments ignored when computing residuals: set IgnoreExpts {practice} # Default filter expression, 1 means nothing gets filtered: set Filter 1 # Default independent variables: set Independents {$EXPT $COND $RNUM} # Default dependent variables: set Dependents {$RSRT} # Subjects with an error rate worse than this are recommended for removal: set QuestCutoff 66.666 # Subjects with avg reading rate over this Z-score are recommended for removal: set RateCutoff 2.5
Before fully analyzing the data, it is a good idea to check that all of the subjects meet reasonable performance criteria. You may wish to discard the data from subjects who make too many comprehension errors or are not reading in a natural fashion. Ordinarily, it is a good idea to perform these tests only on the filler items that are common to all subjects to prevent indirect effects of the different experimental items seen by the subjects. If you are using two experiments as fillers for one another, you may have to perform
To perform some basic tests on the data, run a command like the following:
lingalyzer contrast.cnd -f '[eq $EXPT filler]' -p ../Results
The first argument is the condition file, which isn't actually used in this case, but must be specified. The -f option specifies a filter which discards unwanted data. In this case, we are only keeping data from the "filler" experiment (the filler items), as is recommended.
The final argument must be -p followed by the directory in which the .dat files are located.
Lingalyzer will first report the average question answering correctness rates for the subjects, in sorted order. It will recommend removing any subject with fewer than 2/3 correct answers. You may choose to set the criterion wherever you wish.
Next, it will calculate the average word reading time for each subject, and the mean and standard deviation of these values. Lingalyzer will recommend that any subject whose average word reading rate is over 2.5 std. devs above the mean be removed. Again, you can set your own criterion wherever you wish.
When you actually remove the subjects, it is a good idea to create a "Removed" subdirectory within the Results directory and move the subjects' .dat files there. This way they will not be in the way, but can always be retrieved.
lingalyzer contrast.cnd -c ../Results
Following -c is the name of the directory containing the .dat files. First Lingalyzer will extract all of the data from the .dat files. If you wish to leave some of the files out of the analysis (because subjects are being discarded), it is easiest to create a subdirectory within the Results directory and move the unwanted .dat files there.
Lingalyzer next computes the question answering correctness percentage for each sentence. If there is just one question asked per sentence, this will be either 100 or 0, but it may be different if more questions are asked.
It then determines the subject item number for each item. That is, where did the item occur in the sequence of items seen by the subject, counting practice and filler items as well as experimental items.
Next, Lingalyzer computes the word length/reading time regression equation for each subject. This is done using all of the data except for the practice items, which normally have the experiment name "practice". If you named the practice items differently or would like to exclude other items in computing the residual, you can change the IgnoreExpts parameter in the condition file.
Then Lingalyzer computes the Z-scores for the raw and residual reading times for the purpose of later trimming. The Z-score is the difference between the reading time and the mean reading time, divided by the standard deviation. In computing Z-scores, separate means and standard deviations are computed for each pairing of experiment, condition, and region.
Z-scores are also computed for the question answering times on a per-subject basis. That is, each subject has his or her own mean and standard deviation.
Finally, the information is written to two data files, one for reading times (.rtm) and one for comprehension questions (.qst). The files take the base of their name from the condition file and are written in compressed format to save space. So a condition file named contrast.cnd will result in the creation of the files contrast.rtm.gz and contrast.qst.gz.
The columns in the reading time data file, along with their four-letter codes, are as follows:
| 1 | EXPT: | the experiment name |
| 2 | COND: | the condition name |
| 3 | ITEM: | the item number |
| 4 | SUBJ: | the subject number |
| 5 | SBIN: | the position of the item in the sequence seen by the subject |
| 6 | WNUM: | the word number in the sentence (starting with 1) |
| 7 | WORD: | the actual word |
| 8 | RNUM: | the region number (0 is the default region) |
| 9 | RWRT: | the raw reading time |
| 10 | RWZS: | the raw reading time Z-score |
| 11 | RSRT: | the residual reading time |
| 12 | RSZS: | the residual reading time Z-score |
| 13 | QPCT: | the question answering correctness percentage on this sentence |
Note that the word number in this file starts counting with 1, while the word numbers in the .dat files start with 0.
The columns in the question answering data file are as follows:
| 1 | EXPT: | the experiment name |
| 2 | COND: | the condition name |
| 3 | ITEM: | the item number |
| 4 | SUBJ: | the subject number |
| 5 | SBIN: | the position of the item in the sequence seen by the subject |
| 6 | QTAG: | the question tag, which was appended to the ? or ! in the items file |
| 7 | QNUM: | the question number on this item |
| 8 | QANS: | the actual answer given by the subject |
| 9 | QCRC: | was the subject's answer correct? |
| 10 | RWRT: | the raw reaction time in answering the question |
| 11 | RWZS: | the question answering time Z-score |
The QNUM is only useful if more than one question is asked per item.
Once .rtm and .qst files have been created, the second step in using Lingalyzer is to extract data from the files to produce reports. The first type of report contains columns with independent variables and then the mean, standard error, and number of data points of one or more dependent variables.
The -i option is used to set the independent variables. It should be followed by an expression that evaluates to a list of independent variable values, separated by whitespace. Ordinarily it will consist of a list of four-letter column names enclosed in quotes, with each column name preceded by $. For example, the default expression is '$EXPT $COND $RNUM', which includes the experiment, condition, and region number. A line will appear in the resulting .avg file for each pairing of values for these variables.
The -d option specifies the expression that evaluates to the values of the dependent variable or variables. Normally this will be either '$RWRT', '$RSRT', or '$QCRC', although you may want to produce a report containing both RWRT and RSRT by enclosing both of these codes in quotes, '$RWRT $RSRT'. For each pairing of values of the independent variables, the mean and stderr of the dependent variables will appear in the .avg file.
The -f option specifies the filter expression which determines which data values are included in the analysis and which are ignored. This is a standard Tcl expression that should evaluate to true for any line that should be included in the analysis. It is best to enclose the filter expression in single quotes. The values for the columns for each line are accessed by preceding the name of the column with $. Otherwise, the syntax is largely the same as in C and other programming languages. Here are some examples of typical filter expressions:
The raw reading time Z-score must be less than 3:
-f '$RWZS < 3'
The raw rt Z-score must be less than 3 and more than -1:
-f '$RWZS < 3 && $RWZS > -1'or
-f '($RWZS < 3) && ($RWZS > -1)'
The region number is 4:
-f '$RNUM == 4'
The experiment is equal to exp1:
-f '[eq $EXPT exp1]'
Note that "a == b" can only be used for numbers. The "[eq a b]" function should be used for comparing strings. The condition is not "a":
-f '![eq $COND a]'
The experiment is either exp1 or exp2 (it is "in" the set):
-f '[in $EXPT "exp1 exp2"]'
The condition begins with AB:
-f '[sm $COND AB*]'
Operators for comparing numbers include <, >, <=, >=, ==, and !=. Logical operators include && (and), || (or), and ! (not).
Words should not be compared using == and !=. It is better to use the eq or in procedures. The eq procedure takes two strings and returns TRUE if they are identical. The in procedure takes two arguments, a word and a list of words. It tests if the word is in the list. If the second argument contains just one item, this is equivalent to an eq, but may be slower. Note that this procedure must be enclosed in square brackets. For negation, ! should precede the square brackets.
Words can also be compared to glob-like expressions using the "sm" (string match) command. This is used similarly to "in", except that the second argument is an expression, rather than a list of words. The expression can contain alphanumeric characters or the special symbols * and ?. * matches any string of 0 or more characters. ? matches any single character.
The default filter is "1", which does not discard any of the data.
Once -f, -i, and -d have been specified, the last argument should be either -r or -q. The -r flag causes the analysis to be done on the reading time data and the -q flag causes the analysis to be done on the question answering data. Following either argument is the name of the output file that will be written. The extension .avg will be added to the file name automatically. If - is given in place of the file root, the results will be printed to standard output.
In the example below, the contrast.cnd condition file is read. The filter is set to include only lines for which the residual Z-score is less than 3. The independent variables are the experiment name, condition name, and region numbers. For each pairing of their values, the mean residual reading time and their standard errors will be produced. The final argument causes the analysis to be done on the contrast.rtm file and the results to be written to foo.avg.
lingalyzer contrast.cnd -f '$RSZS < 3' -i '$EXPT $COND $RNUM' -d '$RSRT' -r foo
The foo.avg file will look something like this:
contrast a 0 -26.431 5.390 1053 contrast a 1 -58.347 7.272 178 contrast a 4 -45.261 13.566 176 contrast a 5 -41.905 13.929 177 contrast a 6 -14.726 7.909 353 contrast a 7 -32.069 5.428 707 ... contrast d 5 -16.666 15.717 177 contrast d 6 -6.933 8.012 351 contrast d 7 -24.336 5.882 708 contrast d 8 -32.343 15.845 179 filler a 0 -25.312 0.769 47726 practice - 0 57.009 4.449 3442
In this example, the question answering correctness rate is computed for each subject, discarding the practice items:
lingalyzer contrast.cnd -f '![eq $EXPT practice]' -i '$SUBJ' -d '$QCRC' -q bar
The bar.avg file will look something like this:
1 0.894 0.034 85 2 0.894 0.034 85 3 0.612 0.053 85 4 0.882 0.035 85 5 0.824 0.042 85 ...
In addition to computing averages over subsets of your data, you may wish to simply extract lines or parts of lines from the .rtm or .qst files. This may be useful for checking your filter expression, figuring out why a certain average isn't what you expect it to be, or passing the data on to another analysis program.
Typically, programs like grep or awk are used in Unix to extract lines from a file. The main advantage of using Lingalyzer over awk to extract the lines is that you can refer to columns by name, such as EXPT and SUBJ, rather than by number, which is less convenient.
Data extraction is done using similar command-line arguments to those used in producing average files. However, to extract data, the -e flag must be inserted before -q or -r flags. Following -q or -r is the root file name in which the data will be stored (after appending the .dat extension). You can send the data to standard output rather than a file by giving the file name "-".
Each line produced when extracting data will contain columns based on the fields specified in the list of independent (-i) and dependent (-d) variables. First the independent variables will be listed in order and then the dependent ones. If the lists of independent and dependent variables are both empty, all of the data will be printed.
The following command produces, to standard output, the subject number, item number, and question answering correctness and time for all lines that match the condition c1 from the file blah.qst:
lingalyzer blah.cnd -i '$SUBJ $ITEM' -d '$QCRC $RWRT' -f '[eq $COND c1]' \ -e -q -You can also produce formatted output by adding text or formatting information to the output in either the independent or dependent variable list. For example, the following query:
lingalyzer foo.cnd -i 'Subject $SUBJ, Item $ITEM, Word $WNUM,' \ -d '[format "Residual: %.1f Z-score: %.2f" $RSRT $RSZS]' -e -r -produces output like the following:
Subject 1, Item 1, Word 13, Residual: 216.0 Z-score: 0.83 Subject 1, Item 1, Word 14, Residual: -437.3 Z-score: -0.64 Subject 1, Item 1, Word 15, Residual: -286.3 Z-score: -0.62 Subject 1, Item 1, Word 16, Residual: 261.2 Z-score: 0.14 Subject 1, Item 2, Word 1, Residual: -6.5 Z-score: -0.09 Subject 1, Item 2, Word 2, Residual: 900.7 Z-score: 2.25 Subject 1, Item 2, Word 3, Residual: 122.5 Z-score: 0.51
When performing an ANOVA, the -f filter works just the same, but the dependent variables, specified with -d, must contain exactly one field.
The independent variables, specified with -i, should contain more than one field. The first field will be the random variable. Normally this is either the subject number ($SUBJ) or item number ($ITEM). The other independent variables are the ANOVA factors, and can include any of the standard fields. There is one additional field that will often be useful, $ANOV. If $ANOV is included in the list of independent variables, it will be replaced with the ANOVA_FACTORS given for the experiment and condition in the condition file. This is used when each experimental condition represents a particular set of factor values.
In order to perform an ANOVA, the -a flag must appear prior to the -r or -q flag. This puts Lingalyzer in "anova mode". Following the -a is a list of the column headings for the ANOVA. These are the factor names that will appear in the report produced by anova. It is most convenient if these names start with different letters because anova reports interactions by combining the first character of each factor name. When running in anova mode, the file name that follows -r or -q must be a real file name--you can't write to standard output.
In this example, an ANOVA is performed on region 4 using the subject number as the random variable and the ANOV factors (size and color) as the independent factors, with residual reading time as the dependent variable:
lingalyzer contrast.cnd -f '$RNUM==4' -i '$SUBJ $ANOV' -d '$RSRT' \ -a 'subject size color time' -r region4Two files will be created when this is run. region4.anv contains the data that was fed to anova. region4.anova contains the output of anova.
Lingalyzer provides a mechanism for computing a complete set of pairwise ANOVAS, or t-tests, in a single command. The syntax is the same as for running an ANOVA, but instead of the -a flag, the -t flag is used. The one constraint is that the list of independent variables must have exactly two fields. The first is the random variable, either "$ITEM" or "$SUBJ". The second is a description of the condition or set of factors for this data point. This is most often "$COND". Each value in this column will be paired with every other value and the resulting ANOVAs are written to a ".pwa" file, which stands for "pairwise ANOVA".
The following example performs a set of pairwise ANOVAs by subject, writing the results to "region4.pwa":
lingalyzer contrast.cnd -f '$RNUM==4' -i '$SUBJ $COND' -d '$RSRT' \ -t 'subject condition time' -r region4
In the condition file, create an array that maps from your condition name to a number, for example:
set Length(a) 0 set Length(b) 1 set Length(c) 2Then, instead of using $COND as the independent variable, use the value stored in this array, which is $Length($COND). You could generate the data and pipe it to the regress program for analysis like this:
lingalyzer foo.cnd -i '$Length($COND)' -d '$RSRT' -f '$RNUM==6' -e -r - | regress > r6.regress
You can define a similar array in the condition file to group conditions together for reanalysis. For example, if you want to group condition a with b and c with d, you could puts this in the condition file:
set NewCond(a) AB set NewCond(b) AB set NewCond(c) CD set NewCond(d) CDThen, when you run lingalyzer, use '$NewCond($COND)' instead of '$COND'.


Signed in as {{ googleService.user_info.emails[0].value }}
Signed in as {{ spotify.user_info.emails[0].value }}


Chapter 3. Python Basics
Our next goal is to go through the basic Python syntax, describe some general style guidelines, then brief you on identifiers, variables, and keywords. We will also discuss how memory space for variables is allocated and deallocated. Finally, we will be exposed to a much larger example Python programtaking the plunge, as it were. No need to worry, there are plenty of life preservers around that allow for swimming rather than the alternative.
|


Consider the following polynomial:
Here, be a degree in and let be a constant.
The polynomial can be rewritten as shown below:
Consider.
As , so there must be an integer such that for all .
So
Let
a.
If , then
For a given function m, denote as the set of functions given by
From the given statement , where is a constant.
From equations (1) and (2),
Hence from the definition, .
b.
If , then
For a given function , denote as the set of functions given by
From the given statement , where is a constant.
From equations (1) and (3),
Hence from the definition, .
c.
If , then
For a given function , denote As the set of functions given by
From the given statement , where is a constant.
From equation (1),
Hence from the definition, .
If , then
For a given function , denote as the set of functions given by
From the given statement , where is a constant.
From equations (1) and (4),
Hence from the definition, .
e.
If , then
For a given function , denote as the set of functions given by
From the given statement , where is a constant.
From equations (1) and (5),
Hence from the definition, .
Relative asymptotic growths:
L' Hospital's Rule: In the case where f(n) and g(n) are differentiable functions and
, the limit of can be computed as the limit of their derivatives.
Justifications:
(a)
Apply L' Hospital's Rule k times,
Hence,.
(b)
By applications of L' Hospital’s rule,
Hence, .
(c)
sin n is a periodic function and takes the values in the range [-1, 1].
When sin n=1,
When sin n = -1,.
(d)
Hence, .
(e)
Consider
Take log on both sides.
(d)
Consider .
and thus
And thus,
Finally
The limit lies in the interval [1/2, 1].
a.
Consider the following provided 30 functions:
, ,, ,,,,, , , , , , , , , , , , , , , , , , , , , ,
Consider the following expression to arrange the function:
• The growth of exponential function is larger than any polynomial function. This means that the functions and are the 2 greatest function.
• It is already known.
This implies
or,
Now, apply poweron both sides, therefore
• Consider function
(By using the binary logarithm).
• The iterated logarithmic functions are very slowly growing function.
The value of is the minimum number of logarithmic iteration at is less than 1.
Consider the following function:
Consider the following function:
Where,
• Consider the following function:
Using equation (3.19)
• Consider the following function:
Using equation (3.18)
Therefore, the following is the different equivalence class of each term. Here, the symbol > denotes notation.
b.
Consider the following non-negative function for all function of part (a).
For any value of n, the best and worst time complexity of cannot be and .
a.
Asymptotic notation is used to describe the running time of algorithm in term of function.
big(O) notation: upper bound in above graph represents the big(O) notation.
…… (1)
notation: lower bound in above graph represents the notation.
…… (2)
In both equation (1) and (2), and are the positive constant
is asymptotically non-negative for all the positive constants c,
Such that
Since, from equation (2), the constant c is positive
So,
…… (3)
Similarly, from equation (1),
…… (4)
Hence, from equation (3) and (4),
b.
First discussion is on the omega and the omega infinity notation and then on the basis of this second discussion will be on its advantage or disadvantage,
Omega notation: It is denoted by symbol. It is an asymptotic lower bound notation. It is defined as,
Whereas,
Advantage:
• It has a wider range of values for the notations so a large range of the complexity
• can be analyzed.
• In notation the resource utilization is maximum.
• In notation running time of algorithm will be minimum.
Disadvantage:
As the range is not fixed so it is not possible to determine its limitation and its consequences to an indefinite analysis.
c.
Consider the theorem 3.1,
When is substituted in place of but in the theorem 3.1 is used, then the” if and only if” direction will have modification as:
Because from the author definition,
If and only if
d.
Consider the following formula of the soft theta and soft omega:
(Soft omega):
(Soft theta):
For any two function f(n) and g(n), the function if and only if and .
• These notation are similar to older one only difference is that here the logarithms factor extra added to them.
• This logarithm function used in the case of larger inputs.
• From the definition soft-oh is lower bound in nature and soft-omega is upper bound in nature and soft theta lies in between them.
So, it is obvious that if any function is equal to soft-theta then that function is also equal to soft omega.
Consider the following iterated function:
In above equation is an iterated function of f which is iterated ith times to reduce it to c or less than c.
a.
Consider the following function:
It is required to reduce that function to 0 that is the values of c is 0.
Suppose theis iterated 1 more time therefore the becomes:
Similarly, when is iterated n time therefore, thebecome:
Therefore, it is required to iterate n times function f to reduce it to 0.
Hence, the iterated must be .
Consider the following function:
It is required to reduce that function to 1 that is the values of c is 1.
In logarithmic term when base is equal to its argument then only its answer gets 1.
Therefore, it is required to iterate times function f to reduce it to 1.
Hence, the iterated must be .
Consider the following function:
It is required to reduce that function to 1 that is the values of c is 1.
Suppose theis iterated 1 more time therefore the becomes:
Now, is again iterated, therefore the becomes:
After every iteration the function f gets halves itself. Similarly, when is iterated time therefore, thebecome:
Therefore, it is required to iterate times function f to reduce it to 1.
Hence, the iterated must be .
Consider the following function:
It is required to reduce that function to 2 that is the values of c is 2.
Suppose theis iterated 1 more time therefore the becomes:
Now, is again iterated, therefore the becomes:
After every iteration the function f gets halves itself. Similarly, when is iterated time therefore, thebecome:
In times the function f is reduces it 1. When function f is iterated one less than times then the value of function f at will double the value at times that is 2.
Hence, the iterated must be , ignoring the constant.
Consider the following function:
It is required to reduce that function to 2 that is the values of c is 2.
Suppose theis iterated 1 more time therefore the becomes:
Now, is again iterated, therefore the becomes:
After every iteration the function f power gets halves itself. Therefore after p iteration the become:
After p iteration, . Therefore, the value of p becomes .
Hence, the iterated must be to reduce function f to 2.
Consider the following function:
It is required to reduce that function to 1 that is the values of c is 1.
Suppose theis iterated 1 more time therefore the becomes:
Now, is again iterated, therefore the becomes:
After every iteration the function f power gets halves itself. Therefore after p iteration the become:
After p iteration, .
Hence, it is not possible to reduce function f into 1.
Consider the following function:
It is required to reduce that function to 2 that is the values of c is 2.
Suppose theis iterated 1 more time therefore the becomes:
Now, is again iterated, therefore the becomes:
Therefore after p iteration thebecome:
After p iteration, . Therefore, the value of p becomes .
Hence, the iterated must be to reduce function f to 2.
Consider the following function:
notation is used to determine lower bound it is because it is not symptomatically tight. Definition is as follows:
Now, define as a set.
Hence, the iterated will be to reduce function f to 2.


{{getAuthorName()}} asked about {{question.task.name}}
{{question.user.firstName}} {{question.user.lastName}} asked


| 058:009 Khan | : |
O you who believe! When you hold secret counsel, do it not for sin and wrong-doing, and disobedience towards the Messenger (Muhammad SAW) but do it for Al-Birr (righteousness) and Taqwa (virtues and piety); and fear Allah unto Whom you shall be gathered. |
| 058:009 Maulana | : |
O you who believe, when you confer together in private, give not to each other counsel of sin and revolt and disobedience to the Messenger, but give to each other counsel of goodness and observance of duty. And keep your duty to Allah, to Whom you will be gathered together. |
| 058:009 Pickthal | : |
O ye who believe! When ye conspire together, conspire not together for crime and wrongdoing and disobedience toward the messenger, but conspire together for righteousness and piety, and keep your duty toward Allah, unto whom ye will be gathered. |
| 058:009 Rashad | : |
O you who believe, if you have to confer secretly, you shall not confer to commit sin, transgression, and to disobey the messenger. You shall confer to work righteousness and piety. You shall reverence GOD, before whom you will be summoned. |
| 058:009 Sarwar | : |
Believers, when you hold a secret counsel, let it not be for a sinful, hostile purpose or to disobey the Messenger, but let your counsel take place for virtuous and pious reasons. Have fear of God in whose presence you will all be brought together. |
| 058:009 Shakir | : |
O you who believe! when you confer together in private, do not give to each other counsel of sin and revolt and disobedience to the Messenger, and give to each other counsel of goodness and guarding (against evil); and be careful of (your duty to) Allah, to Whom you shall be gathered together. |
| 058:009 Sherali | : |
O ye who believe ! When you confer together in private, confer not for the purpose of promoting sin and transgression and disobedience to the Messenger, but confer for the purpose of promoting virtue and righteousness, and fear ALLAH unto Whom you shall all be gathered. |
| 058:009 Yusufali | : |
O ye who believe! When ye hold secret counsel, do it not for iniquity and hostility, and disobedience to the Prophet; but do it for righteousness and self-restraint; and fear Allah, to Whom ye shall be brought back. |
Concepts/Themes Covered: أركان الإسلام > التوحيد > توحيد الله تعالي > أوامره Pillars of Islam> Islamic> Oneness of Allah> His Order العمل > العمل الصالح > الإحسان Action(Work)> The Good Deeds> Charity العمل > العمل الطالح > العمل الآثم Action(Work)> Bad Deeds>The Sinful Action الإنسان والعلاقات الأخلاقية > الأخلاق الحميدة > الإحسان Man and The Moral Relations> Good Morals>Charity الإنسان والعلاقات الاجتماعية > المجتمع > آداب المجلس Man and The Social Relations>The Society>The Council Morals العلاقات السياسية والعامة > المؤامرات General and Political Relationships>Conspiracies
This tool uses eight English parallel translations for the Holy Quran imported from Mr. Clay Smith. You can also visit Qurany Concepts for browsing the Quran themes or topics. If you want to search the Holy Quran for keywords, please visit Qurany Keywords.


Student Government Randomized Meetings
Click here to sign up for next week!
See contact information (Google Drive Sign-In REQUIRED)
Week of 11/15
Person 1
Person 2
Benjamin Solder
Camilla Kampmann
Aubry Klingler
Danielle Redhead
Bryten Otting
Alden Marshall
Michael Pontikes
Nicole Flanigan
Avi Patel
Anagha Kikkeri
Nazlee Khadjeheian
Hubbul Rizvi
What should we do together?
A Meal Together
Student organization event
Movie in the Union
6th Street (21+ ;))
Bowling in the Union
Play a video game
Conversation Starters
"What initiatives are you working on?"
"What organizations are you in?"
"Tell me an interesting life story."
"Weirdest thing that happened last week?"
"What problems do you see at UT?"
"What's your week looking like?"


acl acl2012 acl2012-196 acl2012-196-reference knowledge-graph by maker-knowledge-mining
Source: pdf
Author: Brian Roark ; Richard Sproat ; Cyril Allauzen ; Michael Riley ; Jeffrey Sorensen ; Terry Tai
Abstract: In this paper, we present a new collection of open-source software libraries that provides command line binary utilities and library classes and functions for compiling regular expression and context-sensitive rewrite rules into finite-state transducers, and for n-gram language modeling. The OpenGrm libraries use the OpenFst library to provide an efficient encoding of grammars and general algorithms for building, modifying and applying models.