World News Headlines

Coverage of breaking stories

Which expression is equivalent to (f + g)(4)?

source : yahoo.com

Which expression is equivalent to (f + g)(4)?

f(x) = something with “x”

g(x) = something else with “x” as the variable.

Think of a function as a recipe.

“f” is the name of one recipe. “x” is the secret ingredient and everything after the equal sign is the recipe (the instructions on what to do with the secret ingredient, once you are told what it is).

f(4) would simply mean:

Use recipe “f” and secret ingredient “4” (you use 4 wherever you see “x” in the instructions).

(f + g)(x)

would itself be a function (a recipe) created by adding together the instructions from “f” and the instructions from “g”.

Once you have done that, then apply this combined recipe to secret ingredient “4” to get

(f + g)(4)

Example:

f(x) = 4x – 2

g(x) = 3x + 7

f(x) + g(x) = (4x – 2) + (3x + 7)

combining:

(f + g)(x) = 7x + 5

In this example, if you are asked to find (f + g)(4), you would use this combined recipe (the function called “(f+g)” ) and use 4 wherever you see “x”

(f + g)(4) = 7(4) + 5 = 28 + 5 = 33

As it turns out, you get the same result if you do each function separately, then add the results:

f(4) = 14

g(4) = 19

f(4) + g(4) = 14 + 19 = 33

If f (x) = 4 - x2 and g (x) = 6x, which expression is

If f (x) = 4 – x2 and g (x) = 6x, which expression is – If f (x) = 4 – x2 and g (x) = 6x, which expression is equivalent to (g – 1) (3) ? O9-3 – (4 + 3) 2 6 – 3 – (4 – 32) 6 (3) – 4 + 32 6 (3) – 4-32 ОО. Find an answer to your question "If f (x) = 4 – x2 and g (x) = 6x, which expression is equivalent to (g – 1) (3) ?O9-3 – (4 + 3) 2 6 – 3 – (4 – 32) 6 (3) – 4 + 32 6 (3) -" in 📘 Mathematics if you're in doubt about the correctness ofQuestion: Which expressions are equivalent to 2(4f + 2g) Choose 3 answers: 8f +2g 2f(4+2g) 8f +4g 4(2f +g) 4f+4f +4g. Sue makes 50 litres of green paint by mixing litres of yellow paint and litres of blue paint in the ratio 1:4.The expression is equivalent to f (4) and g (4) means that we should find the value of our function when x equals 4. (f+g) (4) means we should find the value of our function as sum, when x equals 4.

Which expressions are equivalent to 2(4f + 2g) Choose 3 – 19. Iffx) = log 4x and g(x) = x2 – 2, which of these expressions is equivalent to f(g(4))? log 4 x log 14 b. log? 16-2 c. log? 14 d. log 4 + log 14 the domain of y=f(xaly 19.Equivalent expressions Calculator online with solution and steps. Detailed step by step solutions to your Equivalent expressions problems online with our math solver and calculator. Solved exercises of Equivalent expressions.8371 views around the world You can reuse this answer Creative Commons License

Which expressions are equivalent to 2(4f + 2g) Choose 3

Which expression is equivalent to (f + g)(4)? f(4) + g(4 – 3 The expression 2− x −1 x +2 is equivalent to 1) 1− 4) f(x) ÷g(x) 24 The scores on a mathematics college-entry exam are normally distributed with a mean of 68 and standard deviation 7.2. Students scoring higher than one standard deviation above the mean willAnswer to Which expression is NOT equivalent to ?F. G. H. J. . Prentice Hall Mathematics, Algebra 2 (0th Edition) Edit edition. Problem 89E from Chapter 7.4: Which expression is NOT equivalent to ?F. G. H. J.Which expression is equivalent to the expression above for all values of q where the expressions is defined? answer choices . Tags: Question 29 . SURVEY . 300 seconds The graphs of linear functions f and g are shown on the grid. Which function is best represented by the graph of g? answer choices . g(x) = f(x) – 4. g(x) = 1 / 3 f(x)

Solved: 4.7 For The Circuit In Fig. P4.: (a) Use The Op-am ...
Which expression is equivalent to the one below(X^2y)(x^4y ...
A, b and c are the vertices of a triangle. a has ...
If f(x) = 4 - x2 and g(x) = 6x, which expression is ...
Solved: G Expressions Are Logically Equivalent By Applying ...
Answered: Find the missing numerator that will… | bartleby
Interpreting Expressions Worksheet Answer Key - Worksheet List
the functions of f (x) and g(x) are graphed. which ...
New Learning Composite Mathematics Class 8 SK Gupta ...
Solved: Please Help With These Two Questions. Which Of The ...
PPT - 6 . The expression (4z + 3)(z - 2) is equivalent to ...

# 4 Mathematical Induction prove 1/(1×2)+1/(2X3)+…+1/n(n+1)=n/(n+1) mathgotserved – .

How to #12 Proof by induction 1^3+2^3+3^3+…+n^3= (n(n+1)/2)^2 n^2(n+1)^2/4 prove mathgotserved – .

Evaluation of Prefix and Postfix expressions using stack – In our previous lesson, we saw what
prefix and postfix expressions are but we did not discuss how we can
evaluate these expressions.
In this lesson we'll see how we can
evaluate prefix and postfix expressions. Algorithms to evaluate prefix and
postfix expressions are similar but I'm going to talk about postfix
evaluation first because its easier to understand and
implement and then I'll talk about evaluation of
prefix. Okay so let's get started. I have written an expression in infix form
here and I first want to convert this to postfix form. As we know in infix form operator is
written in between operands and we want to convert to postfix in
which operator is written after operands. We have already seen how we can do
this in our previous lesson. We need to go step by step just the way we would go in evaluation of infix. We need to go in
order of precedence and in each step we need to identify operands of an operator and we need to
bring the operator in front of the operands. What we can
actually do is we can first resolve operator precedence and put
parenthesis at appropriate places. In this expression
we will first do this multiplication this first
multiplication then we'll do this second multiplication then we will perform this addition and
finally the subtraction. Okay now we will go one
operator at a time, operands for this multiplication
operator are 'A' and 'B'. So this A*B will become AB*. Now next we would need to look at this
multiplication this will transform to cd* and now we can do the change for this addition the two operands are these two expressions in postfix, so I'm placing the plus
operator after these two expressions. Finally for this last operator the operands are this complex expression
and this variable 'e'. So this is how we will look like after the transformation. Finally when we
are done with all the operators we can get rid of all the paranthesis. They're not needed in postfix expression. This is how you can do the conversion
manualy. We will discuss efficient ways of doing this programitically in later lessons. We will discuss algorithms to convert infix to prefix or postfix in later lessons. In this lesson we're
only going to look at algorithms to evaluate prefix and
postfix expressions. Okay so we have this postfix
expression here and we want to evaluate this expression,
let's say for these values of variables a,b,c,d and e. So we have this expression in
terms of values to evaluate. I'll first quickly tell you how you can
evaluate a postfix expression manually. What you need to do is you need to scan
the expression from left to right and find the first occurrence of an
operator like here, multiplication is the first operator.
In postfix expression operands of an operator will always
lie to its left. For the first operator, the preceding two
entities will always be operands. You need to look for the first
occurrence of this pattern operand, operand, operator in the expression
and now you can apply the operator on these two operands and reduced expression. So this is
what I'm getting after evaluating 23*. Now we need to repeat this
process till we are done with all the operators. Once again we need to
scan the expression from left to right and look for the first operator, if the
expression is correct it will be preceeded by two values. So basically we need to look for first
occurrence of this pattern operand, operand, operator. So now we can reduce this. we have 6 and then we have 5*4 20. We are using space as delimeter here, there should be some space in between two operands. Okay so this is
what I have now. Once again I'll look for the first
occurrence of operand, operand and operator. We will go on like this till we are done with all the operators. When I am saying we need to look for first
occurrence of this pattern operand, operand and operator, what I mean by operand here is a value and
not a complex expression itself. The first
operator will always be preceded by two values and if you will give this some thought you will
be able to understand why. If you can see in this expression we are
applying the operators in the same order in which we have them while
parsing from left to right. So first we're applying this leftmost
multiplication on 2 and 3 then we are applying the next
multiplication on 5 and 4 then we're performing the addition and then finally we are performing the
subtraction and whenever we are performing an operation, we're picking the last two operands proceeding the operator in the
expression. So if we have to do this programitically,
if we have to evaluate a postfix expression given to us in a string like this and let's say operands and operators are separated by space we can have some
other delimiter like comma also to separate operands
and operator. Now what we can do is we can parse the
string from left to right. In each step in this parsing, in each
step in the scanning process, we can get a token that will either be an
operator or an operand. What we can do is as we parse from left to right, we can keep track
of all the operands seen so far and I'll come back to how it
will help us. So I'm keeping all the operands so seen so
far in a list. The first entity that we have here is 2 which is an operand so it will go to the
list, next we have 3 which once again is operand so it will go into the list next we have this multiplication
operator. Now this multiplication should be applied to last two operands preceding it last
two operands to the left of it because we already have the elements stored in this list. All we need to do is we need to pick the
last two from this list and perform the operation. It should be 2*3 and with this multiplication we have reduced expression this 23* has now become 6 it has become an operand that can be used by an operator later. We are at this stage right now that I'm
showing in the right. I'll continue the scanning. Next we have an operand, will push this number 5 on to the
list. Next we have 4 which once again will
come to the list and now we have the multiplication operator and it should be applied to the last two
operands in the reduced expression and we should put the result back into the list. This is the stage
where we are right now. So this list actually is storing all the
operands in the reduced expression preceeding the position at which we are during passing. Now for this edition we should take out
the last two elements from the list and then we should put the result back,
next we have an operand we are at this stage right now. Next we have
an operator this subtraction. We will perform this
subtraction and put the result back. Finally when I'm done
scanning the whole expression I'll have only one element left in the list and this will be my final answer this
will be my final result. This is an efficient algorithm. We
are doing only one pass on the string representing the expression and we have our result. The list that we are using here if you could notice is being used in a
special way we are inserting operands one at a time
from one side and then to perform an operation we are
taking out operand from the same side. Whatever is coming in last is getting
out first. This whole thing that we're doing here
with the list can be done efficiently with a stack, which is nothing but a
special kind of list in which elements are inserted and removed from the same side in which
whatever gets in last comes out first. It's called Last In First
Out(LIFO) structure. Let's do this evaluation again. I have drawn
logical representation of stack here, and this time I'm going to use this stack.
I'll also write pseudo code for this algorithm. I'm going to write a function named evaluate postfix that will take a string
as argument. Let's name this string expression exp for expression. In my function here, i'll first create a stack. Now for the sake of simplicity, let's assume that each operand or operator
in the expression will be of only one character. So to get a token or operator,
We can simply run a loop from zero till length of expression -1. So exp[i] will be my operand or operator. If
expression 'i' is operand I should put, push it onto the stack
else if exp[i] is operator we should do two pop operations in the
stack store the value of the operands in some variable. I'm using variable names op1 and op2. Let's say this pop function will remove
an element from top of stack s and also return this element. Once we have the two operands we can perform the operation, I'm using this
variable to store the output. Let's say this function will perform the operation. Now the result should be pushed back onto the stack. If
I have to run through this expression with whatever code I have right now,
then first entity is 2 which is operand so it should be pushed onto the stack.
Next we have 3, once again this will go to the stack.
Next we have this multiplication operator. So we will come to this else if part of
the code. I'll make first pop and I'll store 3 in this variable op1. Well actually this is the second operand,
so I should say this one is op2 and next one will be op1. Once I have popped these two elements I can perform the
operation. As you can see I'm doing the same stuff that I was doing with the list, the only thing is that I'm showing
things vertically. Stack is being shown as a vertical list. I'm
inserting or taking out from the top. Now I'll push the result back onto the
stack. Now we will move to the next entity
which is operand it will go onto the stack. Next 4 will
also go onto the stack and now we have this multiplication, so we
will perform two pop operations. After this operation
is performed result will be pushed back. Next we have
addition. So we will go on like this. We have 26
pushed onto the stack now. Now it's 9 which will go in and
finally we have this subtraction 26-9, 17 will be pushed onto the stack. At this stage we will be done with the loop we are done with all the tokens, all the
operands and operators. The top of stack can be returned as
final result. At this stage we will have only one
element in the stack and this element will be my final result.
You will have to take care of some parsing logic in actual implementation.
Operand can be a number of multiple digits and then we will have delimiter like
space or comma so you'll have to take care of that.
Parsing operand or operator will be some task. If you want to see my implementation you
can check the description of this video for a link. Okay so this was postfix evaluation.
Let's now quickly see how we can do prefix evaluation. Once again I have written this expression in
infix form and I'll first convert it to prefix. We will go in order of precedence. I first
put this paranthesis this 2 * 3 will become *23, this 5 * 4 will become *54 and now we will pick this plus(+) operator whose operands are these two prefix expressions. Finally for the subtraction operator this is
the first operand and this is the second operand. In the last step we can get rid of all the
parenthesis. So this is what I have finally. Let's now
see how we can evaluate a prefix expression like this. We will do it just like postfix this time all we need to do is we need
to scan from right, so we will go from right to left. Once again we will people use a stack if it's an
operand we can push it onto the stack. So here for this example 9 will go onto the stack and now we will go to the next entity in the left, it's 4. Once again we have an operand. It will go onto the stack. Now we have 5. 5 will also be pushed onto the stack and
now we have this multiplication operator. At this stage we need to pop two elements from the stack. This time the first element popped will be the first operand. In postfix the first element popped was
the second operand. This time the second element popped will
be the second operand. For this multiplication, first operand is 5 and second operand is 4. This order is really important for multipication the order doesn't matter but for say division or subtraction this will matter. Result 20 will be pushed onto the stack and we
will keep moving left. Now we have 3 and 2 both will go onto the stack and now we have this multiplication operation. 3 and 2 will be popped and their product 6 will be pushed. Now we have this addition, the two
elements at top are 20 and 6 they will be popped and their sum 26 will be pushed. Finally we have to subtraction. 26 and 9 will be popped out and 17 will be
pushed and finally this is my answer. Prefix evaluation can be performed in couple of other ways also but this
is easiest and most straightforward. Okay so this was prefix
and postfix evaluation using Stack. In coming lessons, we will see efficient algorithms to convert infix to prefix or postfix. This is it
for this lesson. Thanks for Watching! .