ASP.Net TOCASP.NetMiscellaneous Feature ASP.NET Scripting Visual Basic .NET TOCVisual Basic VB.Net KeywordsVB.Net DataVB.Net Declared ElementVB.Net DelegatesVB.Net Object CharacteristicsVB.Net EventsVB.Net InterfacesVB.Net LINQVB.Net Object and Class Draft for Information Only
Content
VB.NET Operators and Expressions
VB.NET Operators and ExpressionsAn operator is a code element that performs an operation on one or more code elements that hold values. Value elements include variables, constants, literals, properties, returns from Function and Operator procedures, and expressions. An expression is a series of value elements combined with operators, which yields a new value. The operators act on the value elements by performing calculations, comparisons, or other operations. Types of OperatorsVisual Basic provides the following types of operators:
The value elements that are combined with an operator are called operands of that operator. Operators combined with value elements form expressions, except for the assignment operator, which forms a statement. For more information, see Statements. Evaluation of ExpressionsThe end result of an expression represents a value, which is typically of a familiar data type such as Boolean, String, or a numeric type. The following are examples of expressions. 5 + 4 ' The preceding expression evaluates to 9. 15 * System.Math.Sqrt(9) + x ' The preceding expression evaluates to 45 plus the value of x. "Concat" & "ena" & "tion" ' The preceding expression evaluates to "Concatenation". 763 < 23 ' The preceding expression evaluates to False. Several operators can perform actions in a single expression or statement, as the following example illustrates. VBx = 45 + y * z ^ 2 In the preceding example, Visual Basic performs the operations in the expression on the right side of the assignment operator (=), then assigns the resulting value to the variable x on the left. There is no practical limit to the number of operators that can be combined into an expression, but an understanding of Operator Precedence in Visual Basic is necessary to ensure that you get the results you expect. See alsoCommon Tasks Performed with Visual Basic OperatorsOperators perform many common tasks involving one or more expressions called operands. Arithmetic and Bitshift TasksThe following table summarizes the available arithmetic and bitshift operations.
Comparison TasksThe following table summarizes the available comparison operations.
Concatenation TasksThe following table summarizes the available concatenation operations.
Logical and Bitwise TasksThe following table summarizes the available logical and bitwise operations.
See alsoArithmetic Operators in Visual BasicArithmetic operators are used to perform many of the familiar arithmetic operations that involve the calculation of numeric values represented by literals, variables, other expressions, function and property calls, and constants. Also classified with arithmetic operators are the bitshift operators, which act at the level of the individual bits of the operands and shift their bit patterns to the left or right. Arithmetic OperationsYou can add two values in an expression together with the + Operator, or subtract one from another with the  Operator (Visual Basic), as the following example demonstrates. VBDim x As Integer x = 67 + 34 x = 32  12 Negation also uses the  Operator (Visual Basic), but with only one operand, as the following example demonstrates. VBDim x As Integer = 65 Dim y As Integer y = x Multiplication and division use the * Operator and / Operator (Visual Basic), respectively, as the following example demonstrates. VBDim y As Double y = 45 * 55.23 y = 32 / 23 Exponentiation uses the ^ Operator, as the following example demonstrates. VBDim z As Double z = 23 ^ 3 ' The preceding statement sets z to 12167 (the cube of 23). Integer division is carried out using the \ Operator (Visual Basic). Integer division returns the quotient, that is, the integer that represents the number of times the divisor can divide into the dividend without consideration of any remainder. Both the divisor and the dividend must be integral types (SByte, Byte, Short, UShort, Integer, UInteger, Long, and ULong) for this operator. All other types must be converted to an integral type first. The following example demonstrates integer division. VBDim k As Integer k = 23 \ 5 ' The preceding statement sets k to 4. Modulus arithmetic is performed using the Mod Operator. This operator returns the remainder after dividing the divisor into the dividend an integral number of times. If both divisor and dividend are integral types, the returned value is integral. If divisor and dividend are floatingpoint types, the returned value is also floatingpoint. The following example demonstrates this behavior. VBDim x As Integer = 100 Dim y As Integer = 6 Dim z As Integer z = x Mod y ' The preceding statement sets z to 4.VB Dim a As Double = 100.3 Dim b As Double = 4.13 Dim c As Double c = a Mod b ' The preceding statement sets c to 1.18. Attempted Division by ZeroDivision by zero has different results depending on the data types involved. In integral divisions (SByte, Byte, Short, UShort, Integer, UInteger, Long, ULong), the .NET Framework throws a DivideByZeroException exception. In division operations on the Decimal or Single data type, the .NET Framework also throws a DivideByZeroException exception. In floatingpoint divisions involving the Double data type, no exception is thrown, and the result is the class member representing NaN, PositiveInfinity, or NegativeInfinity, depending on the dividend. The following table summarizes the various results of attempting to divide a Double value by zero.
When you catch a DivideByZeroException exception, you can use its members to help you handle it. For example, the Message property holds the message text for the exception. For more information, see Try...Catch...Finally Statement. BitShift OperationsA bitshift operation performs an arithmetic shift on a bit pattern. The pattern is contained in the operand on the left, while the operand on the right specifies the number of positions to shift the pattern. You can shift the pattern to the right with the >> Operator or to the left with the << Operator. The data type of the pattern operand must be SByte, Byte, Short, UShort, Integer, UInteger, Long, or ULong. The data type of the shift amount operand must be Integer or must widen to Integer. Arithmetic shifts are not circular, which means the bits shifted off one end of the result are not reintroduced at the other end. The bit positions vacated by a shift are set as follows:
The following example shifts an Integer value both left and right. VBDim lResult, rResult As Integer Dim pattern As Integer = 12 ' The loworder bits of pattern are 0000 1100. lResult = pattern << 3 ' A left shift of 3 bits produces a value of 96. rResult = pattern >> 2 ' A right shift of 2 bits produces value of 3. Arithmetic shifts never generate overflow exceptions. Bitwise OperationsIn addition to being logical operators, Not, Or, And, and Xor also perform bitwise arithmetic when used on numeric values. For more information, see "Bitwise Operations" in Logical and Bitwise Operators in Visual Basic. Type SafetyOperands should normally be of the same type. For example, if you are doing addition with an Integer variable, you should add it to another Integer variable, and you should assign the result to a variable of type Integer as well. One way to ensure good typesafe coding practice is to use the Option Strict Statement. If you set Option Strict On, Visual Basic automatically performs typesafe conversions. For example, if you try to add an Integer variable to a Double variable and assign the value to a Double variable, the operation proceeds normally, because an Integer value can be converted to Double without loss of data. Typeunsafe conversions, on the other hand, cause a compiler error with Option Strict On. For example, if you try to add an Integer variable to a Double variable and assign the value to an Integer variable, a compiler error results, because a Double variable cannot be implicitly converted to type Integer. If you set Option Strict Off, however, Visual Basic allows implicit narrowing conversions to take place, although they can result in the unexpected loss of data or precision. For this reason, we recommend that you use Option Strict On when writing production code. For more information, see Widening and Narrowing Conversions. See also
Comparison Operators in Visual BasicComparison operators compare two expressions and return a Boolean value that represents the relationship of their values. There are operators for comparing numeric values, operators for comparing strings, and operators for comparing objects. All three types of operators are discussed herein. Comparing Numeric ValuesVisual Basic compares numeric values using six numeric comparison operators. Each operator takes as operands two expressions that evaluate to numeric values. The following table lists the operators and shows examples of each.
Comparing StringsVisual Basic compares strings using the Like Operator as well as the numeric comparison operators. The Like operator allows you to specify a pattern. The string is then compared against the pattern, and if it matches, the result is True. Otherwise, the result is False. The numeric operators allow you to compare String values based on their sort order, as the following example shows. "73" < "9" ' The result of the preceding comparison is True. The result in the preceding example is True because the first character in the first string sorts before the first character in the second string. If the first characters were equal, the comparison would continue to the next character in both strings, and so on. You can also test equality of strings using the equality operator, as the following example shows. "734" = "734" ' The result of the preceding comparison is True. If one string is a prefix of another, such as "aa" and "aaa", the longer string is considered to be greater than the shorter string. The following example illustrates this. "aaa" > "aa" ' The result of the preceding comparison is True. The sort order is based on either a binary comparison or a textual comparison depending on the setting of Option Compare. For more information see Option Compare Statement. Comparing ObjectsVisual Basic compares two object reference variables with the Is Operator and the IsNot Operator. You can use either of these operators to determine if two reference variables refer to the same object instance. The following example illustrates this. VBDim x As testClass Dim y As New testClass() x = y If x Is y Then ' Insert code to run if x and y point to the same instance. End If In the preceding example, x Is y evaluates to True, because both variables refer to the same instance. Contrast this result with the following example. VBDim x As New customer() Dim y As New customer() If x Is y Then ' Insert code to run if x and y point to the same instance. End If In the preceding example, x Is y evaluates to False, because although the variables refer to objects of the same type, they refer to different instances of that type. When you want to test for two objects not pointing to the same instance, the IsNot operator lets you avoid a grammatically clumsy combination of Not and Is. The following example illustrates this. VBDim a As New classA() Dim b As New classB() If a IsNot b Then ' Insert code to run if a and b point to different instances. End If In the preceding example, If a IsNot b is equivalent to If Not a Is b. Comparing Object TypeYou can test whether an object is of a particular type with the TypeOf...Is expression. The syntax is as follows: TypeOf <objectexpression> Is <typename> When typename specifies an interface type, then the TypeOf...Is expression returns True if the object implements the interface type. When typename is a class type, then the expression returns True if the object is an instance of the specified class or of a class that derives from the specified class. The following example illustrates this. VBDim x As System.Windows.Forms.Button x = New System.Windows.Forms.Button() If TypeOf x Is System.Windows.Forms.Control Then ' Insert code to run if x is of type System.Windows.Forms.Control. End If In the preceding example, the TypeOf x Is Control expression evaluates to True because the type of x is Button, which inherits from Control. For more information, see TypeOf Operator. See also
How to: Test Whether Two Objects Are the SameIf you have two variables that refer to objects, you can use either the Is or IsNot operator, or both, to determine whether they refer to the same instance. To test whether two objects are the same
You might want to take a certain action depending on whether two objects refer to the same instance. The preceding example compares control c against the active control on form f. If there is no active control, or if there is one but it is not the same control instance as c, then the If statement fails and the procedure returns without further processing. Whether you use Is or IsNot is a matter of personal convenience to you. One might be easier to read than the other in a given expression. See alsoHow to: Match a String against a PatternIf you want to find out if an expression of the String Data Type satisfies a pattern, then you can use the Like Operator. Like takes two operands. The left operand is a string expression, and the right operand is a string containing the pattern to be used for matching. Like returns a Boolean value indicating whether the string expression satisfies the pattern. You can match each character in the string expression against a specific character, a wildcard character, a character list, or a character range. The positions of the specifications in the pattern string correspond to the positions of the characters to be matched in the string expression. To match a character in the string expression against a specific character
To match a character in the string expression against a wildcard character
To match a character in the string expression against a list of characters
To match a character in the string expression against a range of characters
Matching Empty StringsLike treats the sequence [] as a zerolength string (""). You can use [] to test whether the entire string expression is empty, but you cannot use it to test if a particular position in the string expression is empty. If an empty position is one of the options you need to test for, you can use Like more than once. To match a character in the string expression against a list of characters or no character
See alsoConcatenation Operators in Visual BasicConcatenation operators join multiple strings into a single string. There are two concatenation operators, + and &. Both carry out the basic concatenation operation, as the following example shows. VBDim x As String = "Mic" & "ro" & "soft" Dim y As String = "Mic" + "ro" + "soft" ' The preceding statements set both x and y to "Microsoft". These operators can also concatenate String variables, as the following example shows. VBDim a As String = "abc" Dim d As String = "def" Dim z As String = a & d Dim w As String = a + d ' The preceding statements set both z and w to "abcdef". Differences Between the Two Concatenation OperatorsThe + Operator has the primary purpose of adding two numbers. However, it can also concatenate numeric operands with string operands. The + operator has a complex set of rules that determine whether to add, concatenate, signal a compiler error, or throw a runtime InvalidCastException exception. The & Operator is defined only for String operands, and it always widens its operands to String, regardless of the setting of Option Strict. The & operator is recommended for string concatenation because it is defined exclusively for strings and reduces your chances of generating an unintended conversion. Performance: String and StringBuilderIf you do a significant number of manipulations on a string, such as concatenations, deletions, and replacements, your performance might profit from the StringBuilder class in the System.Text namespace. It takes an extra instruction to create and initialize a StringBuilder object, and another instruction to convert its final value to a String, but you might recover this time because StringBuilder can perform faster. See also
Logical and Bitwise Operators in Visual BasicLogical operators compare Boolean expressions and return a Boolean result. The And, Or, AndAlso, OrElse, and Xor operators are binary because they take two operands, while the Not operator is unary because it takes a single operand. Some of these operators can also perform bitwise logical operations on integral values. Unary Logical OperatorThe Not Operator performs logical negation on a Boolean expression. It yields the logical opposite of its operand. If the expression evaluates to True, then Not returns False; if the expression evaluates to False, then Not returns True. The following example illustrates this. VBDim x, y As Boolean x = Not 23 > 14 y = Not 23 > 67 ' The preceding statements set x to False and y to True. Binary Logical OperatorsThe And Operator performs logical conjunction on two Boolean expressions. If both expressions evaluate to True, then And returns True. If at least one of the expressions evaluates to False, then And returns False. The Or Operator performs logical disjunction or inclusion on two Boolean expressions. If either expression evaluates to True, or both evaluate to True, then Or returns True. If neither expression evaluates to True, Or returns False. The Xor Operator performs logical exclusion on two Boolean expressions. If exactly one expression evaluates to True, but not both, Xor returns True. If both expressions evaluate to True or both evaluate to False, Xor returns False. The following example illustrates the And, Or, and Xor operators. VBDim a, b, c, d, e, f, g As Boolean a = 23 > 14 And 11 > 8 b = 14 > 23 And 11 > 8 ' The preceding statements set a to True and b to False. c = 23 > 14 Or 8 > 11 d = 23 > 67 Or 8 > 11 ' The preceding statements set c to True and d to False. e = 23 > 67 Xor 11 > 8 f = 23 > 14 Xor 11 > 8 g = 14 > 23 Xor 8 > 11 ' The preceding statements set e to True, f to False, and g to False. ShortCircuiting Logical OperationsThe AndAlso Operator is very similar to the And operator, in that it also performs logical conjunction on two Boolean expressions. The key difference between the two is that AndAlso exhibits shortcircuiting behavior. If the first expression in an AndAlso expression evaluates to False, then the second expression is not evaluated because it cannot alter the final result, and AndAlso returns False. Similarly, the OrElse Operator performs shortcircuiting logical disjunction on two Boolean expressions. If the first expression in an OrElse expression evaluates to True, then the second expression is not evaluated because it cannot alter the final result, and OrElse returns True. ShortCircuiting TradeOffsShortcircuiting can improve performance by not evaluating an expression that cannot alter the result of the logical operation. However, if that expression performs additional actions, shortcircuiting skips those actions. For example, if the expression includes a call to a Function procedure, that procedure is not called if the expression is shortcircuited, and any additional code contained in the Function does not run. Therefore, the function might run only occasionally, and might not be tested correctly. Or the program logic might depend on the code in the Function. The following example illustrates the difference between And, Or, and their shortcircuiting counterparts. VBDim amount As Integer = 12 Dim highestAllowed As Integer = 45 Dim grandTotal As IntegerVB If amount > highestAllowed And checkIfValid(amount) Then ' The preceding statement calls checkIfValid(). End If If amount > highestAllowed AndAlso checkIfValid(amount) Then ' The preceding statement does not call checkIfValid(). End If If amount < highestAllowed Or checkIfValid(amount) Then ' The preceding statement calls checkIfValid(). End If If amount < highestAllowed OrElse checkIfValid(amount) Then ' The preceding statement does not call checkIfValid(). End IfVB Function checkIfValid(ByVal checkValue As Integer) As Boolean If checkValue > 15 Then MsgBox(CStr(checkValue) & " is not a valid value.") ' The MsgBox warning is not displayed if the call to ' checkIfValid() is part of a shortcircuited expression. Return False Else grandTotal += checkValue ' The grandTotal value is not updated if the call to ' checkIfValid() is part of a shortcircuited expression. Return True End If End Function In the preceding example, note that some important code inside checkIfValid() does not run when the call is shortcircuited. The first If statement calls checkIfValid() even though 12 > 45 returns False, because And does not shortcircuit. The second If statement does not call checkIfValid(), because when 12 > 45 returns False, AndAlso shortcircuits the second expression. The third If statement calls checkIfValid() even though 12 < 45 returns True, because Or does not shortcircuit. The fourth If statement does not call checkIfValid(), because when 12 < 45 returns True, OrElse shortcircuits the second expression. Bitwise OperationsBitwise operations evaluate two integral values in binary (base 2) form. They compare the bits at corresponding positions and then assign values based on the comparison. The following example illustrates the And operator. VBDim x As Integer x = 3 And 5 The preceding example sets the value of x to 1. This happens for the following reasons:
The bitwise Or operation is similar, except that a 1 is assigned to the result bit if either or both of the compared bits is 1. Xor assigns a 1 to the result bit if exactly one of the compared bits (not both) is 1. Not takes a single operand and inverts all the bits, including the sign bit, and assigns that value to the result. This means that for signed positive numbers, Not always returns a negative value, and for negative numbers, Not always returns a positive or zero value. The AndAlso and OrElse operators do not support bitwise operations. Note Bitwise operations can be performed on integral types only. Floatingpoint values must be converted to integral types before bitwise operation can proceed. See also
Efficient Combination of OperatorsComplex expressions can contain many different operators. The following example illustrates this. x = (45 * (y + z)) ^ (2 / 85) * 5 + z Creating complex expressions such as the one in the preceding example requires a thorough understanding of the rules of operator precedence. For more information, see Operator Precedence in Visual Basic. Parenthetical ExpressionsOften you want operations to proceed in a different order from that determined by operator precedence. Consider the following example. x = z * y + 4 The preceding example multiplies z by y, then adds the result to 4. But if you want to add y and 4 before multiplying the result by z, you can override normal operator precedence by using parentheses. By enclosing an expression in parentheses, you force that expression to be evaluated first, regardless of operator precedence. To force the preceding example to do the addition first, you could rewrite it as in the following example. x = z * (y + 4) The preceding example adds y and 4, then multiplies that sum by z. Nested Parenthetical ExpressionsYou can nest expressions in multiple levels of parentheses to override precedence even further. The expressions most deeply nested in parentheses are evaluated first, followed by the next most deeply nested, and so on to the least deeply nested, and finally the expressions outside parentheses. The following example illustrates this. x = (z * 4) ^ (y * (z + 2)) In the preceding example, z + 2 is evaluated first, then the other parenthetical expressions. Exponentiation, which normally has higher precedence than addition or multiplication, is evaluated last in this example because the other expressions are enclosed in parentheses. See also
How to: Calculate Numeric ValuesYou can calculate numeric values through the use of numeric expressions. A numeric expression is an expression that contains literals, constants, and variables representing numeric values, and operators that act on those values. Calculating Numeric ValuesTo calculate a numeric value
To store a numeric value
Multiple OperatorsIf the numeric expression contains more than one operator, the order in which they are evaluated is determined by the rules of operator precedence. To override the rules of operator precedence, you enclose expressions in parentheses, as in the above example; the enclosed expressions are evaluated first. To override normal operator precedence
See also
Value ComparisonsComparison operators can be used to construct expressions that compare the values of numeric variables. These expressions return a Boolean value based on whether the comparison is true or false. Examples of such an expression are as follows. 45 > 26 26 > 45 The first expression evaluates to True, because 45 is greater than 26. The second example evaluates to False, because 26 is not greater than 45. You can also compare numeric expressions in this fashion. The expressions you compare can themselves be complex expressions, as in the following example. x / 45 * (y +17) >= System.Math.Sqrt(z) / (p  (x * 16)) The preceding complex expression includes literals, variables, and function calls. The expressions on both sides of the comparison operator are evaluated, and the resulting values are then compared using the >= comparison operator. If the value of the expression on the left side is greater than or equal to the value of the expression on the right, the entire expression evaluates to True; otherwise, it evaluates to False. Expressions that compare values are most commonly used in If...Then constructions, as in the following example. VBIf x > 50 Then ' Insert code to run if x is greater than 50. Else ' Insert code to run if x is less than or equal to 50. End If The = sign is a comparison operator as well as an assignment operator. When used as a comparison operator, it evaluates whether the value on the left is equal to the value on the right, as shown in the following example. VBIf x = 50 Then ' Insert code to continue program. End If You can also use a comparison expression anywhere a Boolean value is needed, such as in an If, While, Loop, or ElseIf statement, or when assigning to or passing a value to a Boolean variable. In the following example, the value returned by the comparison expression is assigned to a Boolean variable. VBDim x As Boolean x = 50 < 30 ' The preceding statement assigns False to x. See also
Boolean ExpressionsA Boolean expression is an expression that evaluates to a value of the Boolean Data Type: True or False. Boolean expressions can take several forms. The simplest is the direct comparison of the value of a Boolean variable to a Boolean literal, as shown in the following example. VBIf newCustomer = True Then ' Insert code to execute if newCustomer = True. Else ' Insert code to execute if newCustomer = False. End If Two Meanings of the = OperatorNotice that the assignment statement newCustomer = True looks the same as the expression in the preceding example, but it performs a different function and is used differently. In the preceding example, the expression newCustomer = True represents a Boolean value, and the = sign is interpreted as a comparison operator. In a standalone statement, the = sign is interpreted as an assignment operator and assigns the value on the right to the variable on the left. The following example illustrates this. VBIf newCustomer = True Then newCustomer = False End If For further information, see Value Comparisons and Statements. Comparison OperatorsComparison operators such as =, <, >, <>, <=, and >= produce Boolean expressions by comparing the expression on the left side of the operator to the expression on the right side of the operator and evaluating the result as True or False. The following example illustrates this. 42 < 81 Because 42 is less than 81, the Boolean expression in the preceding example evaluates to True. For more information on this kind of expression, see Value Comparisons. Comparison Operators Combined with Logical OperatorsComparison expressions can be combined using logical operators to produce more complex Boolean expressions. The following example demonstrates the use of comparison operators in conjunction with a logical operator. x > y And x < 1000 In the preceding example, the value of the overall expression depends on the values of the expressions on each side of the And operator. If both expressions are True, then the overall expression evaluates to True. If either expression is False, then the entire expression evaluates to False. ShortCircuiting OperatorsThe logical operators AndAlso and OrElse exhibit behavior known as shortcircuiting. A shortcircuiting operator evaluates the left operand first. If the left operand determines the value of the entire expression, then program execution proceeds without evaluating the right expression. The following example illustrates this. VBIf 45 < 12 AndAlso testFunction(3) = 81 Then ' Add code to continue execution. End If In the preceding example, the operator evaluates the left expression, 45 < 12. Because the left expression evaluates to False, the entire logical expression must evaluate to False. Program execution thus skips execution of the code within the If block without evaluating the right expression, testFunction(3). This example does not call testFunction() because the left expression falsifies the entire expression. Similarly, if the left expression in a logical expression using OrElse evaluates to True, execution proceeds to the next line of code without evaluating the right expression, because the left expression has already validated the entire expression. Comparison with NonShortCircuiting OperatorsBy contrast, both sides of the logical operator are evaluated when the logical operators And and Or are used. The following example illustrates this. VBIf 45 < 12 And testFunction(3) = 81 Then ' Add code to continue execution. End If The preceding example calls testFunction() even though the left expression evaluates to False. Parenthetical ExpressionsYou can use parentheses to control the order of evaluation of Boolean expressions. Expressions enclosed by parentheses evaluate first. For multiple levels of nesting, precedence is granted to the most deeply nested expressions. Within parentheses, evaluation proceeds according to the rules of operator precedence. For more information, see Operator Precedence in Visual Basic. See also
Source/Reference
©sideway ID: 201000006 Last Updated: 6/10/2020 Revision: 0 Ref: References
Latest Updated Links

Home_{ 5} Business Management HBR_{ 3} Information Recreation Hobbies_{ 8} Culture Chinese_{ 1097} English_{ 337} Reference_{ 67} Computer Hardware_{ 151} Software Application_{ 198} Digitization_{ 25} Latex_{ 9} Manim_{ 121} Numeric_{ 19} Programming Web_{ 283} Unicode_{ 494} HTML_{ 65} CSS_{ 58} ASP.NET_{ 174} OS_{ 389} DeskTop_{ 7} Python_{ 19} Knowledge Mathematics Formulas_{ 8} Algebra_{ 25} Number Theory_{ 206} Trigonometry_{ 18} Geometry_{ 21} Calculus_{ 67} Complex Analysis_{ 21} Engineering Tables_{ 8} Mechanical Mechanics_{ 1} Rigid Bodies Statics_{ 92} Dynamics_{ 37} Fluid_{ 5} Fluid Kinematics_{ 5} Control Process Control_{ 1} Acoustics_{ 19} FiniteElement_{ 2} Physics Electric_{ 27} Biology_{ 1} Geography_{ 1} 
Copyright © 20002020 Sideway . All rights reserved Disclaimers last modified on 06 September 2019