PVS static analyzer - 5.0 Release
This page tracks the progress of #55347. Upload any changesets which fix bugs to that report. Items from the "critical" list are colored red.
The initial run of the static analyzer is still available at PVS static analyzer - 5.0 - Run 1
Add
text-decoration: line-through;
to cross an item off the list when it has been done.
Add
WON'T FIX
and the strike through tag for any bugs that will not be fixed in this round.
| Location | Code | Message | ||
|---|---|---|---|---|
| Fails/Info | ||||
special-casing-table.h (73) |
V011 | Presence of #line directives may cause some diagnostic messages to have incorrect file name and line number. | ||
lex.cc (27) |
V011 | Presence of #line directives may cause some diagnostic messages to have incorrect file name and line number. | ||
oct-parse.h (221) |
V011 | Presence of #line directives may cause some diagnostic messages to have incorrect file name and line number. | ||
oct-gperf.h (32) |
V011 | Presence of #line directives may cause some diagnostic messages to have incorrect file name and line number. | ||
lex.cc (1) |
V002 | Some diagnostic messages may contain incorrect line number in this file. | ||
oct-parse.cc (77) |
V011 | Presence of #line directives may cause some diagnostic messages to have incorrect file name and line number. | ||
oct-parse.cc (1) |
V002 | Some diagnostic messages may contain incorrect line number in this file. | ||
ls-oct-text.cc (1) |
V002 | Some diagnostic messages may contain incorrect line number in this file. | ||
oct-tex-lexer.cc (24) |
V011 | Presence of #line directives may cause some diagnostic messages to have incorrect file name and line number. | ||
oct-tex-parser.h (51) |
V011 | Presence of #line directives may cause some diagnostic messages to have incorrect file name and line number. | ||
oct-tex-lexer.cc (1) |
V002 | Some diagnostic messages may contain incorrect line number in this file. | ||
oct-tex-parser.cc (72) |
V011 | Presence of #line directives may cause some diagnostic messages to have incorrect file name and line number. | ||
dNDArray.cc (1) |
V002 | Some diagnostic messages may contain incorrect line number in this file. | ||
fNDArray.cc (1) |
V002 | Some diagnostic messages may contain incorrect line number in this file. | ||
| General Analysis (GA) | ||||
areadlink-with-size.c (59) |
V547 | Expression 'symlink_max < INITIAL_LIMIT_BOUND' is always true. | ||
canonicalize.c (161) |
V547 | Expression 'prefix_len' is always false. | ||
canonicalize.c (297) |
V547 | Expression 'pfxlen' is always false. | ||
careadlinkat.c (145) |
V547 | Expression 'buf_size_max < (18446744073709551615UL)' is always true. | ||
md2.c (60) |
V512 | A call of the 'memcpy' function will lead to underflow of the buffer 'ctx->X'. | ||
md4.c (245) |
V512 | A call of the 'memcpy' function will lead to underflow of the buffer 'ctx->buffer'. | ||
md5.c (279) |
V512 | A call of the 'memcpy' function will lead to underflow of the buffer 'ctx->buffer'. | ||
md5.c (316) |
V1003 | The macro 'FF' is a dangerous expression. The parameters 'b', 'c', 'd' must be surrounded by parentheses. | ||
md5.c (318) |
V1003 | The macro 'FH' is a dangerous expression. The parameters 'b', 'c', 'd' must be surrounded by parentheses. | ||
md5.c (319) |
V1003 | The macro 'FI' is a dangerous expression. The parameters 'b', 'c', 'd' must be surrounded by parentheses. | ||
md5.c (372) |
V1003 | The macro 'CYCLIC' is a dangerous expression. The parameters 'w', 's' must be surrounded by parentheses. | ||
sha1.c (266) |
V512 | A call of the 'memcpy' function will lead to underflow of the buffer 'ctx->buffer'. | ||
sha1.c (307) |
V1003 | The macro 'F1' is a dangerous expression. The parameters 'B', 'C', 'D' must be surrounded by parentheses. | ||
sha1.c (308) |
V1003 | The macro 'F2' is a dangerous expression. The parameters 'B', 'C', 'D' must be surrounded by parentheses. | ||
sha1.c (309) |
V1003 | The macro 'F3' is a dangerous expression. The parameters 'B', 'C', 'D' must be surrounded by parentheses. | ||
sha1.c (310) |
V1003 | The macro 'F4' is a dangerous expression. The parameters 'B', 'C', 'D' must be surrounded by parentheses. | ||
sha1.c (338) |
V1003 | The macro 'M' is a dangerous expression. The parameter 'I' must be surrounded by parentheses. | ||
sha256.c (185) |
V785 | Constant expression in switch statement. | ||
sha256.c (345) |
V512 | A call of the 'memcpy' function will lead to underflow of the buffer 'ctx->buffer'. | ||
sha256.c (401) |
V1003 | The macro 'F2' is a dangerous expression. The parameters 'A', 'B', 'C' must be surrounded by parentheses. | ||
sha256.c (402) |
V1003 | The macro 'F1' is a dangerous expression. The parameters 'E', 'F', 'G' must be surrounded by parentheses. | ||
sha256.c (432) |
V1003 | The macro 'S0' is a dangerous expression. The parameter 'x' must be surrounded by parentheses. | ||
sha256.c (433) |
V1003 | The macro 'S1' is a dangerous expression. The parameter 'x' must be surrounded by parentheses. | ||
sha256.c (437) |
V1003 | The macro 'M' is a dangerous expression. The parameter 'I' must be surrounded by parentheses. | ||
sha512.c (186) |
V785 | Constant expression in switch statement. | ||
sha512.c (346) |
V512 | A call of the 'memcpy' function will lead to underflow of the buffer 'ctx->buffer'. | ||
u64.h (31) |
V1003 | The macro 'u64rol' is a dangerous expression. The parameter 'n' must be surrounded by parentheses. | ||
dirname-lgpl.c (38) |
V547 | Expression 'prefix_length != 0' is always false. | ||
dirname-lgpl.c (76) |
V560 | A part of conditional expression is always false: length == 0. | ||
basename-lgpl.c (70) |
V560 | A part of conditional expression is always false: prefix_len. | ||
filemode.c (170) |
V501 | There are identical sub-expressions to the left and to the right of the '-' operator: (statp)->st_mode - (statp)->st_mode | ||
filemode.c (174) |
V501 | There are identical sub-expressions to the left and to the right of the '-' operator: (statp)->st_mode - (statp)->st_mode | ||
filemode.c (176) |
V501 | There are identical sub-expressions to the left and to the right of the '-' operator: (statp)->st_mode - (statp)->st_mode | ||
filemode.c (174) |
V517 | The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 174, 176. | ||
filemode.c (172) |
V517 | The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 172, 178. | ||
filemode.c (170) |
V517 | The use of 'if (A) {...} else if (A) {...}' pattern was detected. There is a probability of logical error presence. Check lines: 170, 174. | ||
nstrftime.c (1463) |
V536 | Be advised that the utilized constant value is represented by an octal form. Oct: 024, Dec: 20. | ||
gettext.h (154) |
V547 | Expression 'translation == msg_ctxt_id' is always true. | ||
gettext.h (235) |
V547 | Expression 'translation != msg_ctxt_id' is always false. | ||
gettext.h (241) |
V558 | Function returns the pointer to temporary local object. | ||
gettext.h (240) |
V547 | Expression 'found_translation' is always false. | ||
tempname.c (208) |
V526 | The 'memcmp' function returns 0 if corresponding buffers are equal. Consider examining the condition for mistakes. | ||
tmpdir.c (133) |
V549 | The first argument of 'strcmp' function is equal to the second argument. | ||
u-casemap.h (286) |
V769 | The 'result' pointer in the 'result + length' expression could be nullptr. In such case, resulting value will be senseless and it should not be used. | ||
u-conv-to-enc.h (62) |
V522 | There might be dereferencing of a potential null pointer 'scaled_offsets'. | ||
u32-to-u8.c (66) |
V769 | The 'result' pointer in the 'result + length' expression could be nullptr. In such case, resulting value will be senseless and it should not be used. | ||
u8-to-u32.c (97) |
V522 | There might be dereferencing of a potential null pointer 'result'. | ||
u8-to-u32.c (105) |
V641 | The size of the allocated memory buffer is not a multiple of the element size. | ||
xmalloc.c (61) |
V701 | realloc() possible leak: when realloc() fails in allocating memory, original pointer 'p' is lost. Consider assigning realloc() to a temporary pointer. | ||
xmalloc.c (86) |
V575 | The potential null pointer is passed into 'memset' function. Inspect the first argument. | ||
xmalloc.c (113) |
V575 | The potential null pointer is passed into 'memcpy' function. Inspect the first argument. | ||
mktime.c (142) |
V610 | Unspecified behavior. Check the shift operator '>>'. The left operand '-one' is negative. | ||
mktime.c (142) |
V547 | Expression '- one >> 1 == - 1' is always true. | ||
mktime.c (150) |
V560 | A part of conditional expression is always true: (!((time_t) 0 < (time_t) - 1)). | ||
mktime.c (153) |
V547 | Expression is always false. | ||
mktime.c (274) |
V547 | Expression '* t < mktime_min' is always false. | ||
mktime.c (275) |
V547 | Expression '* t <= mktime_max' is always true. | ||
mktime.c (473) |
V560 | A part of conditional expression is always true: mktime_min <= gt. | ||
mktime.c (473) |
V560 | A part of conditional expression is always true: gt <= mktime_max. | ||
mktime.c (506) |
V560 | A part of conditional expression is always true: mktime_min <= t. | ||
mktime.c (506) |
V560 | A part of conditional expression is always true: t <= mktime_max. | ||
mktime.c (506) |
V560 | A part of conditional expression is always false: !(mktime_min <= t && t <= mktime_max). | ||
time_rz.c (71) |
V564 | The '|' operator is applied to bool type value. You've probably forgotten to include parentheses or intended to use the '||' operator. | ||
time_rz.c (77) |
V792 | The 'isdst_differ' function located to the right of the operator '|' will be called regardless of the value of the left operand. Perhaps, it is better to use '||'. | ||
vasnprintf.c (1896) |
V769 | The 'result' pointer in the 'result + length' expression could be nullptr. In such case, resulting value will be senseless and it should not be used. | ||
vasnprintf.c (4943) |
V501 | There are identical sub-expressions to the left and to the right of the '/' operator: sizeof (char) / sizeof (char) | ||
vasnprintf.c (4962) |
V501 | There are identical sub-expressions to the left and to the right of the '/' operator: sizeof (char) / sizeof (char) | ||
vasnprintf.c (4963) |
V501 | There are identical sub-expressions to the left and to the right of the '/' operator: sizeof (char) / sizeof (char) | ||
vasnprintf.c (4964) |
V501 | There are identical sub-expressions to the left and to the right of the '/' operator: sizeof (char) / sizeof (char) | ||
vasnprintf.c (5234) |
V501 | There are identical sub-expressions to the left and to the right of the '/' operator: sizeof (char) / sizeof (char) | ||
vasnprintf.c (5250) |
V501 | There are identical sub-expressions to the left and to the right of the '/' operator: sizeof (char) / sizeof (char) | ||
vasnprintf.c (5251) |
V501 | There are identical sub-expressions to the left and to the right of the '/' operator: sizeof (char) / sizeof (char) | ||
vasnprintf.c (1785) |
V553 | The length of 'vasnprintf' function's body is more than 2000 lines long. You should consider refactoring the code. | ||
dim-vector.h (224) |
V659 | Declarations of functions with 'elem' name differ in the 'const' keyword only, but the bodies of these functions have different composition. This is suspicious and can possibly be an error. Check lines: 218, 224. | ||
idx-vector.h (634) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (654) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (661) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (670) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (708) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (726) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (733) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (742) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (780) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (798) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (805) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (814) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (850) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (865) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (872) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (880) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (922) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (938) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (945) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.h (955) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
lo-mappers.h (63) |
V601 | The bool type is implicitly cast to the double type. | ||
lo-mappers.h (64) |
V601 | The bool type is implicitly cast to the float type. | ||
lo-mappers.h (160) |
V550 | An odd precise comparison: fabs(x - t) == 0.5. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-mappers.h (171) |
V550 | An odd precise comparison: fabsf(x - t) == 0.5f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-mappers.h (240) |
V550 | An odd precise comparison: x == round(x). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-mappers.h (241) |
V550 | An odd precise comparison: x == round(x). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-inttypes.h (1307) |
V550 | An odd precise comparison: x == static_cast<double> (y). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-inttypes.h (1307) |
V550 | An odd precise comparison: static_cast<double> (x) == y. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-inttypes.h (1308) |
V550 | An odd precise comparison: x != static_cast<double> (y). It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
oct-inttypes.h (1308) |
V550 | An odd precise comparison: static_cast<double> (x) != y. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
mx-inlines.cc (627) |
V550 | An odd precise comparison: x != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
mx-inlines.cc (633) |
V550 | An odd precise comparison: x == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
mx-inlines.cc (639) |
V550 | An odd precise comparison: x != 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
mx-inlines.cc (645) |
V550 | An odd precise comparison: x == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
mx-inlines.cc (652) |
V550 | An odd precise comparison: x != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
mx-inlines.cc (658) |
V550 | An odd precise comparison: x == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
mx-inlines.cc (664) |
V550 | An odd precise comparison: x != 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
mx-inlines.cc (670) |
V550 | An odd precise comparison: x == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Sparse.h (393) |
V659 | Declarations of functions with 'checkelem' name differ in the 'const' keyword only, but the bodies of these functions have different composition. This is suspicious and can possibly be an error. Check lines: 330, 393. | ||
Sparse.h (401) |
V659 | Declarations of functions with 'checkelem' name differ in the 'const' keyword only, but the bodies of these functions have different composition. This is suspicious and can possibly be an error. Check lines: 342, 401. | ||
Sparse.h (409) |
V659 | Declarations of functions with 'checkelem' name differ in the 'const' keyword only, but the bodies of these functions have different composition. This is suspicious and can possibly be an error. Check lines: 353, 409. | ||
Sparse.h (419) |
V659 | Declarations of functions with 'elem' name differ in the 'const' keyword only, but the bodies of these functions have different composition. This is suspicious and can possibly be an error. Check lines: 363, 419. | ||
Sparse.h (421) |
V659 | Declarations of functions with 'elem' name differ in the 'const' keyword only, but the bodies of these functions have different composition. This is suspicious and can possibly be an error. Check lines: 369, 421. | ||
Sparse.h (493) |
V659 | Declarations of functions with 'data' name differ in the 'const' keyword only, but the bodies of these functions have different composition. This is suspicious and can possibly be an error. Check lines: 486, 493. | ||
Sparse.h (506) |
V659 | Declarations of functions with 'ridx' name differ in the 'const' keyword only, but the bodies of these functions have different composition. This is suspicious and can possibly be an error. Check lines: 495, 506. | ||
Sparse.h (504) |
V659 | Declarations of functions with 'ridx' name differ in the 'const' keyword only, but the bodies of these functions have different composition. This is suspicious and can possibly be an error. Check lines: 496, 504. | ||
Sparse.h (519) |
V659 | Declarations of functions with 'cidx' name differ in the 'const' keyword only, but the bodies of these functions have different composition. This is suspicious and can possibly be an error. Check lines: 508, 519. | ||
Sparse.h (517) |
V659 | Declarations of functions with 'cidx' name differ in the 'const' keyword only, but the bodies of these functions have different composition. This is suspicious and can possibly be an error. Check lines: 509, 517. | ||
MSparse.cc (549) |
V501 | There are identical sub-expressions to the left and to the right of the '/' operator: Zero / Zero | ||
Range.h (33) |
V690 | The 'Range' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-base.h (201) |
V690 | The 'octave_base_value' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ovl.h (170) |
V659 | Declarations of functions with 'elem' name differ in the 'const' keyword only, but the bodies of these functions have different composition. This is suspicious and can possibly be an error. Check lines: 162, 170. | ||
Array.h (454) |
V512 | Instantiation of Array <int>: A call of the 'compute_index' function will lead to overflow of the buffer 'ra_idx.data()'. | ||
lo-regexp.h (196) |
V690 | The 'match_element' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
__delaunayn__.cc (159) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
idx-vector.h (566) |
V524 | It is odd that the body of 'checkelem' function is fully equivalent to the body of 'xelem' function. | ||
Array.h (413) |
V524 | It is odd that the body of 'columns' function is fully equivalent to the body of 'cols' function. | ||
mx-inlines.cc (611) |
V524 | It is odd that the body of 'xis_true' function is fully equivalent to the body of 'logical_value' function. | ||
DiagArray2.h (89) |
V524 | It is odd that the body of 'columns' function is fully equivalent to the body of 'cols' function. | ||
DiagArray2.h (93) |
V524 | It is odd that the body of 'length' function is fully equivalent to the body of 'diag_length' function. | ||
Sparse.h (260) |
V524 | It is odd that the body of 'columns' function is fully equivalent to the body of 'cols' function. | ||
dMatrix.h (132) |
V524 | It is odd that the body of 'transpose' function is fully equivalent to the body of 'hermitian' function. | ||
Range.h (89) |
V524 | It is odd that the body of 'columns' function is fully equivalent to the body of 'cols' function. | ||
fMatrix.h (136) |
V524 | It is odd that the body of 'transpose' function is fully equivalent to the body of 'hermitian' function. | ||
PermMatrix.h (55) |
V524 | It is odd that the body of 'columns' function is fully equivalent to the body of 'cols' function. | ||
ov-base.h (255) |
V524 | It is odd that the body of 'numeric_demotion_function' function is fully equivalent to the body of 'numeric_conversion_function' function. | ||
Cell.h (123) |
V524 | It is odd that the body of 'any' function is fully equivalent to the body of 'all' function. | ||
oct-map.h (393) |
V524 | It is odd that the body of 'columns' function is fully equivalent to the body of 'cols' function. | ||
ov-fcn.h (93) |
V524 | It is odd that the body of 'time_checked' function is fully equivalent to the body of 'time_parsed' function. | ||
oct-sort.h (197) |
V730 | It is possible that not all members of a class are initialized inside the constructor. Consider inspecting: pending. | ||
chol.h (42) |
V730 | Not all members of a class are initialized inside the constructor. Consider inspecting: is_upper. | ||
chol.h (57) |
V730 | Not all members of a class are initialized inside the constructor. Consider inspecting: is_upper. | ||
mx-inlines.cc (675) |
V1003 | The macro 'OP_RED_SUMSQ' is a dangerous expression. The parameter 'el' must be surrounded by parentheses. | ||
Array.h (454) |
V512 | Instantiation of Array < octave_f77_int_type >: A call of the 'compute_index' function will lead to overflow of the buffer 'ra_idx.data()'. | ||
ov-base-mat.h (177) |
V659 | Declarations of functions with 'matrix_ref' name differ in the 'const' keyword only, but the bodies of these functions have different composition. This is suspicious and can possibly be an error. Check lines: 171, 177. | ||
ov-fcn-handle.h (45) |
V690 | The 'octave_fcn_handle' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
hook-fcn.h (35) |
V690 | The 'base_hook_function' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
input.h (203) |
V690 | The 'base_reader' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
oct-handle.h (118) |
V550 | An odd precise comparison: a.value() == b.value(). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-handle.h (124) |
V550 | An odd precise comparison: a.value() != b.value(). It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-classdef.h (1601) |
V522 | There might be dereferencing of a potential null pointer. | ||
ov-classdef.h (1610) |
V522 | There might be dereferencing of a potential null pointer. | ||
call-stack.h (52) |
V690 | The 'stack_frame' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
__eigs__.cc (333) |
V550 | An odd precise comparison: tmp.double_value() != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
__eigs__.cc (340) |
V550 | An odd precise comparison: tmp.double_value() != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
__eigs__.cc (369) |
V550 | An odd precise comparison: tmp.double_value() != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
__eigs__.cc (462) |
V550 | An odd precise comparison: sigmai != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
token.h (166) |
V773 | The 'm_str' pointer was not released in destructor. A memory leak is possible. | ||
token.h (166) |
V773 | The 'm_sr' pointer was not released in destructor. A memory leak is possible. | ||
token.h (166) |
V773 | The 'm_superclass_info' pointer was not released in destructor. A memory leak is possible. | ||
ov-base-mat.h (68) |
V773 | The 'idx_cache' pointer was not released in destructor. A memory leak is possible. | ||
__glpk__.cc (106) |
V550 | An odd precise comparison: lb[i] != ub[i]. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
__glpk__.cc (290) |
V636 | The expression was implicitly cast from 'long' type to 'double' type. Consider utilizing an explicit type cast to avoid the loss of a fractional part. An example: double A = (double)(X) / Y;. | ||
graphics.h (273) |
V690 | The 'base_property' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
graphics.h (426) |
V690 | The 'string_property' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
graphics.h (472) |
V690 | The 'string_array_property' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
graphics.h (672) |
V690 | The 'text_label_property' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
graphics.h (916) |
V690 | The 'radio_property' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
graphics.h (1054) |
V690 | The 'color_property' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
graphics.h (1168) |
V690 | The 'double_property' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
graphics.h (1257) |
V547 | Expression 'finite_constraint == NOT_INF' is always true. | ||
graphics.h (1263) |
V550 | An odd precise comparison: new_val != current_val. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
graphics.h (1280) |
V690 | The 'double_radio_property' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
graphics.h (1362) |
V690 | The 'array_property' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
graphics.h (1626) |
V690 | The 'handle_property' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
graphics.h (1671) |
V690 | The 'any_property' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
graphics.h (1704) |
V690 | The 'children_property' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
graphics.h (1773) |
V550 | An odd precise comparison: hchild == old_gh. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.h (1895) |
V690 | The 'callback_property' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
graphics.h (2914) |
V678 | An object is used as an argument to its own method. Consider checking the first actual argument of the 'override_defaults' function. | ||
graphics.h (4644) |
V553 | The length of 'properties' class's declaration is more than 2000 lines long. You should consider refactoring the code. | ||
graphics.h (4641) |
V553 | The length of 'axes' class's declaration is more than 2000 lines long. You should consider refactoring the code. | ||
__init_fltk__.cc (190) |
V550 | An odd precise comparison: m_number != new_number. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
__init_fltk__.cc (1389) |
V601 | The integer type is implicitly cast to the char type. | ||
__init_fltk__.cc (1855) |
V668 | There is no sense in testing the 'instance' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
graphics.h (6755) |
V524 | It is odd that the body of 'update_titlefontweight' function is fully equivalent to the body of 'update_fontweight' function. | ||
__init_fltk__.cc (742) |
V773 | The 'm_menubar' pointer was not released in destructor. A memory leak is possible. | ||
__init_gnuplot__.cc (209) |
V565 | An empty exception handler. Silent suppression of exceptions can hide the presence of bugs in source code during testing. | ||
__voronoi__.cc (156) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
ov-base-scalar.h (44) |
V690 | The 'octave_base_scalar' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-scalar.h (49) |
V690 | The 'octave_scalar' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
audiodevinfo.cc (915) |
V547 | Expression 'type == TYPE_UINT16' is always true. | ||
audiodevinfo.cc (1363) |
V547 | Expression 'sample_l32 & 0x00800000' is always false. | ||
audiodevinfo.cc (1366) |
V547 | Expression 'sample_r32 & 0x00800000' is always false. | ||
audiodevinfo.cc (1441) |
V547 | Expression 'sample_l32 & 0x00800000' is always false. | ||
audiodevinfo.cc (1444) |
V547 | Expression 'sample_r32 & 0x00800000' is always false. | ||
audiodevinfo.cc (2233) |
V668 | There is no sense in testing the 'recorder' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
audiodevinfo.cc (2257) |
V547 | Expression 'is_function' is always false. | ||
ov-base-scalar.h (95) |
V524 | It is odd that the body of 'any' function is fully equivalent to the body of 'all' function. | ||
ov-intx.h (516) |
V524 | It is odd that the body of 'scalar_value' function is fully equivalent to the body of 'double_value' function. | ||
ov-intx.h (518) |
V524 | It is odd that the body of 'float_scalar_value' function is fully equivalent to the body of 'float_value' function. | ||
audioread.cc (119) |
V550 | An odd precise comparison: octave::math::x_nint(dstart) != dstart. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
audioread.cc (120) |
V550 | An odd precise comparison: octave::math::x_nint(dend) != dend. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
audioread.cc (162) |
V525 | The code contains the collection of similar blocks. Check items 'int16NDArray', 'int32NDArray', 'int32NDArray' in lines 162, 165, 168. | ||
ccolamd.cc (175) |
V550 | An odd precise comparison: knobs[3] != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ccolamd.cc (199) |
V550 | An odd precise comparison: knobs[2] != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ccolamd.cc (447) |
V550 | An odd precise comparison: knobs[2] != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
sparse-chol.h (46) |
V690 | The 'sparse_chol' class implements the '=' operator, but lacks a copy constructor. It is dangerous to use such a class. | ||
chol.cc (253) |
V614 | Uninitialized variable 'info' used. | ||
chol.cc (266) |
V614 | Uninitialized variable 'info' used. | ||
chol.cc (286) |
V614 | Uninitialized variable 'info' used. | ||
chol.cc (299) |
V614 | Uninitialized variable 'info' used. | ||
chol.cc (414) |
V614 | Uninitialized variable 'info' used. | ||
chol.cc (425) |
V614 | Uninitialized variable 'info' used. | ||
chol.cc (441) |
V614 | Uninitialized variable 'info' used. | ||
chol.cc (452) |
V614 | Uninitialized variable 'info' used. | ||
convhulln.cc (171) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
gzip.cc (429) |
V507 | Pointer to local array 'buf_out' is stored outside the scope of this array. Such a pointer will become invalid. | ||
gzip.cc (420) |
V507 | Pointer to local array 'buf_in' is stored outside the scope of this array. Such a pointer will become invalid. | ||
symbfact.cc (123) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
symbfact.cc (124) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
symbfact.cc (213) |
V550 | An odd precise comparison: spu == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
symbfact.cc (317) |
V601 | The 'false' value is implicitly cast to the integer type. Inspect the fourth argument. | ||
symbfact.cc (317) |
V601 | The 'true' value is implicitly cast to the integer type. Inspect the fifth argument. | ||
symbfact.cc (133) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
BaseControl.cc (216) |
V522 | There might be dereferencing of a potential null pointer 'm'. | ||
ButtonControl.cc (88) |
V550 | An odd precise comparison: dValue != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ButtonControl.cc (88) |
V550 | An odd precise comparison: dValue != 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ButtonControl.cc (90) |
V550 | An odd precise comparison: dValue == up.get_min(). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ButtonControl.cc (102) |
V550 | An odd precise comparison: dValue == up.get_max(). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ov-struct.h (45) |
V690 | The 'octave_struct' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-struct.h (168) |
V690 | The 'octave_scalar_struct' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ButtonGroup.cc (214) |
V522 | There might be dereferencing of a potential null pointer 'm'. | ||
Canvas.cc (633) |
V550 | An odd precise comparison: tmpgo.get_handle() != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
Figure.cc (751) |
V522 | There might be dereferencing of a potential null pointer 'dynamic_cast< QChildEvent * > (xevent)'. | ||
Figure.cc (943) |
V550 | An odd precise comparison: old_dpr != new_dpr. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
gl-select.h (44) |
V730 | Not all members of a class are initialized inside the constructor. Consider inspecting: xp, yp. | ||
ListBoxControl.cc (235) |
V522 | There might be dereferencing of a potential null pointer 'm'. | ||
ListBoxControl.cc (249) |
V522 | There might be dereferencing of a potential null pointer 'm'. | ||
Panel.cc (190) |
V522 | There might be dereferencing of a potential null pointer 'm'. | ||
Table.cc (108) |
V550 | An odd precise comparison: d == floor(d). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Table.cc (109) |
V550 | An odd precise comparison: d == floor(d). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Table.cc (367) |
V758 | The 'c_str' reference becomes invalid when temporary object returned by a function is destroyed. | ||
Table.cc (367) |
V576 | Incorrect format. Consider checking the third actual argument of the 'sscanf' function. A pointer to the intmax_t type is expected. | ||
Table.cc (368) |
V758 | The 'c_str' reference becomes invalid when temporary object returned by a function is destroyed. | ||
Table.cc (368) |
V576 | Incorrect format. Consider checking the third actual argument of the 'sscanf' function. A pointer to the uintmax_t type is expected. | ||
Table.cc (369) |
V758 | The 'c_str' reference becomes invalid when temporary object returned by a function is destroyed. | ||
Table.cc (369) |
V576 | Incorrect format. Consider checking the third actual argument of the 'sscanf' function. A pointer to the intmax_t type is expected. | ||
Table.cc (370) |
V758 | The 'c_str' reference becomes invalid when temporary object returned by a function is destroyed. | ||
Table.cc (370) |
V576 | Incorrect format. Consider checking the third actual argument of the 'sscanf' function. A pointer to the uintmax_t type is expected. | ||
Table.cc (371) |
V758 | The 'c_str' reference becomes invalid when temporary object returned by a function is destroyed. | ||
Table.cc (371) |
V576 | Incorrect format. Consider checking the third actual argument of the 'sscanf' function. A pointer to the intmax_t type is expected. | ||
Table.cc (372) |
V758 | The 'c_str' reference becomes invalid when temporary object returned by a function is destroyed. | ||
Table.cc (372) |
V576 | Incorrect format. Consider checking the third actual argument of the 'sscanf' function. A pointer to the uintmax_t type is expected. | ||
Table.cc (373) |
V758 | The 'c_str' reference becomes invalid when temporary object returned by a function is destroyed. | ||
Table.cc (373) |
V576 | Incorrect format. Consider checking the third actual argument of the 'sscanf' function. A pointer to the intmax_t type is expected. | ||
Table.cc (374) |
V758 | The 'c_str' reference becomes invalid when temporary object returned by a function is destroyed. | ||
Table.cc (374) |
V576 | Incorrect format. Consider checking the third actual argument of the 'sscanf' function. A pointer to the uintmax_t type is expected. | ||
Table.cc (1324) |
V560 | A part of conditional expression is always true: widget. | ||
Table.cc (1523) |
V522 | There might be dereferencing of a potential null pointer 'm'. | ||
Table.cc (1561) |
V522 | There might be dereferencing of a potential null pointer 'k'. | ||
Table.cc (1663) |
V522 | There might be dereferencing of a potential null pointer 'm'. | ||
ToolBar.cc (137) |
V522 | There might be dereferencing of a potential null pointer 'ae'. | ||
shared-fcns.h (127) |
V560 | A part of conditional expression is always true: op == oep. | ||
mkoctfile.cc (164) |
V656 | Variables 'vars["DATADIR"]', 'vars["DATAROOTDIR"]' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'prepend_octave_home("share")' expression. Check lines: 163, 164. | ||
async-system-wrapper.c (80) |
V631 | Consider inspecting the 'execl' function call. Defining an absolute path to the file or directory is considered a poor style. | ||
uniconv-wrappers.c (79) |
V575 | The potential null pointer is passed into 'memcpy' function. Inspect the first argument. Check lines: 79, 78. | ||
uniconv-wrappers.c (101) |
V575 | The potential null pointer is passed into 'memcpy' function. Inspect the first argument. Check lines: 101, 100. | ||
ov-bool.h (48) |
V690 | The 'octave_bool' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-complex.h (48) |
V690 | The 'octave_complex' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-float.h (50) |
V690 | The 'octave_float_scalar' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-flt-complex.h (48) |
V690 | The 'octave_float_complex' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-str-mat.h (49) |
V690 | The 'octave_char_matrix_str' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-str-mat.h (182) |
V690 | The 'octave_char_matrix_sq_str' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-float.h (149) |
V524 | It is odd that the body of 'scalar_value' function is fully equivalent to the body of 'double_value' function. | ||
op-b-b.cc (75) |
V524 | It is odd that the body of 'oct_unop_hermitian' function is fully equivalent to the body of 'oct_unop_transpose' function. | ||
ov-base-sparse.h (47) |
V690 | The 'octave_base_sparse' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-cx-sparse.h (48) |
V690 | The 'octave_sparse_complex_matrix' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-re-sparse.h (49) |
V690 | The 'octave_sparse_matrix' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-bool-sparse.h (48) |
V690 | The 'octave_sparse_bool_matrix' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-range.h (83) |
V773 | The 'idx_cache' pointer was not released in destructor. A memory leak is possible. | ||
ov-base-diag.h (43) |
V690 | The 'octave_base_diag' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-cx-diag.h (35) |
V690 | The 'octave_complex_diag_matrix' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-flt-cx-diag.h (35) |
V690 | The 'octave_float_complex_diag_matrix' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-re-diag.h (35) |
V690 | The 'octave_diag_matrix' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-class.h (50) |
V690 | The 'octave_class' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
op-cm-cs.cc (52) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cm-cs.cc (98) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cm-cs.cc (88) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-cm-cs.cc (90) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-cm-s.cc (55) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cm-s.cc (96) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cm-s.cc (86) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-cm-s.cc (88) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-cm-scm.cc (60) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cm-sm.cc (60) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-cm.cc (69) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-cm.cc (102) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-cm.cc (88) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-cs-cm.cc (94) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-cs-cs.cc (50) |
V550 | An odd precise comparison: x == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-cs.cc (80) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-cs.cc (95) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-cs.cc (117) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-cs.cc (132) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-cs.cc (143) |
V550 | An odd precise comparison: v1.complex_value() != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-cs-cs.cc (143) |
V550 | An odd precise comparison: v2.complex_value() != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-cs-cs.cc (151) |
V550 | An odd precise comparison: v1.complex_value() != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-cs-cs.cc (151) |
V550 | An odd precise comparison: v2.complex_value() != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-cs-cs.cc (55) |
V524 | It is odd that the body of 'oct_unop_transpose' function is fully equivalent to the body of 'oct_unop_uplus' function. | ||
op-cs-cs.cc (108) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-cs-cs.cc (110) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-cs-cs.cc (123) |
V524 | It is odd that the body of 'oct_binop_el_pow' function is fully equivalent to the body of 'oct_binop_pow' function. | ||
op-cs-cs.cc (125) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-cs-m.cc (73) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-m.cc (97) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-m.cc (86) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-cs-m.cc (90) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-cs-s.cc (51) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-s.cc (66) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-s.cc (74) |
V550 | An odd precise comparison: v1.complex_value() == v2.scalar_value(). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-s.cc (77) |
V550 | An odd precise comparison: v1.complex_value() != v2.scalar_value(). It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-cs-s.cc (88) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-s.cc (103) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-s.cc (114) |
V550 | An odd precise comparison: v1.complex_value() != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-cs-s.cc (122) |
V550 | An odd precise comparison: v1.complex_value() != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-cs-s.cc (79) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-cs-s.cc (81) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-cs-s.cc (94) |
V524 | It is odd that the body of 'oct_binop_el_pow' function is fully equivalent to the body of 'oct_binop_pow' function. | ||
op-cs-s.cc (96) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-cs-scm.cc (57) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-scm.cc (89) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-scm.cc (116) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-scm.cc (102) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-cs-sm.cc (58) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-sm.cc (89) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-sm.cc (116) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-cs-sm.cc (104) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-cs-sm.cc (108) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
ov-flt-re-diag.h (35) |
V690 | The 'octave_float_diag_matrix' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
op-dm-scm.cc (378) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-dm-scm.cc (402) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-dm-scm.cc (426) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-dm-sm.cc (142) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcm-fcs.cc (57) |
V550 | An odd precise comparison: d == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcm-fcs.cc (106) |
V550 | An odd precise comparison: d == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcm-fcs.cc (94) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-fcm-fcs.cc (97) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-fcm-fs.cc (60) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcm-fs.cc (110) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcm-fs.cc (98) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-fcm-fs.cc (101) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-fcs-fcm.cc (76) |
V550 | An odd precise comparison: d == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcs-fcm.cc (111) |
V550 | An odd precise comparison: d == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcs-fcm.cc (95) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-fcs-fcm.cc (102) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-fcs-fcs.cc (48) |
V550 | An odd precise comparison: x == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcs-fcs.cc (78) |
V550 | An odd precise comparison: d == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcs-fcs.cc (93) |
V550 | An odd precise comparison: d == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcs-fcs.cc (115) |
V550 | An odd precise comparison: d == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcs-fcs.cc (130) |
V550 | An odd precise comparison: d == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcs-fcs.cc (141) |
V550 | An odd precise comparison: v1.float_complex_value() != 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-fcs-fcs.cc (142) |
V550 | An odd precise comparison: v2.float_complex_value() != 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-fcs-fcs.cc (150) |
V550 | An odd precise comparison: v1.float_complex_value() != 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-fcs-fcs.cc (151) |
V550 | An odd precise comparison: v2.float_complex_value() != 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-fcs-fcs.cc (53) |
V524 | It is odd that the body of 'oct_unop_transpose' function is fully equivalent to the body of 'oct_unop_uplus' function. | ||
op-fcs-fcs.cc (106) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-fcs-fcs.cc (108) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-fcs-fcs.cc (121) |
V524 | It is odd that the body of 'oct_binop_el_pow' function is fully equivalent to the body of 'oct_binop_pow' function. | ||
op-fcs-fcs.cc (123) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-fcs-fm.cc (74) |
V550 | An odd precise comparison: d == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcs-fm.cc (107) |
V550 | An odd precise comparison: d == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcs-fm.cc (93) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-fcs-fm.cc (100) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-fcs-fs.cc (54) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcs-fs.cc (69) |
V550 | An odd precise comparison: d == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcs-fs.cc (77) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcs-fs.cc (80) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-fcs-fs.cc (91) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcs-fs.cc (106) |
V550 | An odd precise comparison: d == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fcs-fs.cc (117) |
V550 | An odd precise comparison: v1.float_complex_value() != 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-fcs-fs.cc (125) |
V550 | An odd precise comparison: v1.float_complex_value() != 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-fcs-fs.cc (82) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-fcs-fs.cc (84) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-fcs-fs.cc (97) |
V524 | It is odd that the body of 'oct_binop_el_pow' function is fully equivalent to the body of 'oct_binop_pow' function. | ||
op-fcs-fs.cc (99) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-fm-fcs.cc (59) |
V550 | An odd precise comparison: d == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fm-fcs.cc (105) |
V550 | An odd precise comparison: d == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fm-fcs.cc (95) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-fm-fcs.cc (98) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-fm-fs.cc (51) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fm-fs.cc (96) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fm-fs.cc (87) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-fm-fs.cc (89) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-fs-fcm.cc (82) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fs-fcm.cc (117) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fs-fcm.cc (101) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-fs-fcm.cc (108) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-fs-fcs.cc (54) |
V550 | An odd precise comparison: d == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fs-fcs.cc (69) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fs-fcs.cc (77) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fs-fcs.cc (80) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-fs-fcs.cc (91) |
V550 | An odd precise comparison: d == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fs-fcs.cc (106) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fs-fcs.cc (118) |
V550 | An odd precise comparison: v2.float_complex_value() != 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-fs-fcs.cc (127) |
V550 | An odd precise comparison: v2.float_complex_value() != 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-fs-fcs.cc (82) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-fs-fcs.cc (84) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-fs-fcs.cc (97) |
V524 | It is odd that the body of 'oct_binop_el_pow' function is fully equivalent to the body of 'oct_binop_pow' function. | ||
op-fs-fcs.cc (99) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-fs-fm.cc (69) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fs-fm.cc (102) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fs-fm.cc (88) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-fs-fm.cc (95) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-fs-fs.cc (50) |
V550 | An odd precise comparison: x == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fs-fs.cc (74) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fs-fs.cc (89) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fs-fs.cc (97) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fs-fs.cc (100) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-fs-fs.cc (111) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fs-fs.cc (126) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-fs-fs.cc (102) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-fs-fs.cc (104) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-fs-fs.cc (117) |
V524 | It is odd that the body of 'oct_binop_el_pow' function is fully equivalent to the body of 'oct_binop_pow' function. | ||
op-fs-fs.cc (119) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-i16-i16.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v2.scalar_value()) < Epsilon. | ||
op-i16-i16.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v1.scalar_value()) < Epsilon. | ||
op-i16-i16.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v2.float_scalar_value()) < Epsilon. | ||
op-i16-i16.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v1.float_scalar_value()) < Epsilon. | ||
op-i16-i16.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-i16-i16.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i16-i16.cc (96) |
V550 | An odd precise comparison: v2.scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i16-i16.cc (96) |
V550 | An odd precise comparison: v1.scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i16-i16.cc (96) |
V550 | An odd precise comparison: v2.float_scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i16-i16.cc (96) |
V550 | An odd precise comparison: v1.float_scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_mul' function is fully equivalent to the body of 'oct_binop_ss_mul' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_div' function is fully equivalent to the body of 'oct_binop_ss_div' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_pow' function is fully equivalent to the body of 'oct_binop_ss_pow' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_ldiv' function is fully equivalent to the body of 'oct_binop_ss_ldiv' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_mul' function is fully equivalent to the body of 'oct_binop_ssx_mul' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_div' function is fully equivalent to the body of 'oct_binop_ssx_div' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_pow' function is fully equivalent to the body of 'oct_binop_ssx_pow' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_ldiv' function is fully equivalent to the body of 'oct_binop_ssx_ldiv' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_mul' function is fully equivalent to the body of 'oct_binop_sxs_mul' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_div' function is fully equivalent to the body of 'oct_binop_sxs_div' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_pow' function is fully equivalent to the body of 'oct_binop_sxs_pow' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_ldiv' function is fully equivalent to the body of 'oct_binop_sxs_ldiv' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_mul' function is fully equivalent to the body of 'oct_binop_ssfx_mul' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_div' function is fully equivalent to the body of 'oct_binop_ssfx_div' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_pow' function is fully equivalent to the body of 'oct_binop_ssfx_pow' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_ldiv' function is fully equivalent to the body of 'oct_binop_ssfx_ldiv' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_mul' function is fully equivalent to the body of 'oct_binop_sfxs_mul' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_div' function is fully equivalent to the body of 'oct_binop_sfxs_div' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_pow' function is fully equivalent to the body of 'oct_binop_sfxs_pow' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_ldiv' function is fully equivalent to the body of 'oct_binop_sfxs_ldiv' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sm_el_mul' function is fully equivalent to the body of 'oct_binop_sm_mul' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sm_ldiv' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_smx_el_mul' function is fully equivalent to the body of 'oct_binop_smx_mul' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_smx_el_ldiv' function is fully equivalent to the body of 'oct_binop_smx_ldiv' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxm_el_mul' function is fully equivalent to the body of 'oct_binop_sxm_mul' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sxm_ldiv' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_smfx_el_mul' function is fully equivalent to the body of 'oct_binop_smfx_mul' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_smfx_el_ldiv' function is fully equivalent to the body of 'oct_binop_smfx_ldiv' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxm_el_mul' function is fully equivalent to the body of 'oct_binop_sfxm_mul' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sfxm_ldiv' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ms_el_mul' function is fully equivalent to the body of 'oct_binop_ms_mul' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ms_el_div' function is fully equivalent to the body of 'oct_binop_ms_div' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_msx_el_mul' function is fully equivalent to the body of 'oct_binop_msx_mul' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_msx_el_div' function is fully equivalent to the body of 'oct_binop_msx_div' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_mxs_el_mul' function is fully equivalent to the body of 'oct_binop_mxs_mul' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_mxs_el_div' function is fully equivalent to the body of 'oct_binop_mxs_div' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_msfx_el_mul' function is fully equivalent to the body of 'oct_binop_msfx_mul' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_msfx_el_div' function is fully equivalent to the body of 'oct_binop_msfx_div' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_mfxs_el_mul' function is fully equivalent to the body of 'oct_binop_mfxs_mul' function. | ||
op-i16-i16.cc (96) |
V524 | It is odd that the body of 'oct_binop_mfxs_el_div' function is fully equivalent to the body of 'oct_binop_mfxs_div' function. | ||
op-i32-i32.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v2.scalar_value()) < Epsilon. | ||
op-i32-i32.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v1.scalar_value()) < Epsilon. | ||
op-i32-i32.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v2.float_scalar_value()) < Epsilon. | ||
op-i32-i32.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v1.float_scalar_value()) < Epsilon. | ||
op-i32-i32.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-i32-i32.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i32-i32.cc (96) |
V550 | An odd precise comparison: v2.scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i32-i32.cc (96) |
V550 | An odd precise comparison: v1.scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i32-i32.cc (96) |
V550 | An odd precise comparison: v2.float_scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i32-i32.cc (96) |
V550 | An odd precise comparison: v1.float_scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_mul' function is fully equivalent to the body of 'oct_binop_ss_mul' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_div' function is fully equivalent to the body of 'oct_binop_ss_div' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_pow' function is fully equivalent to the body of 'oct_binop_ss_pow' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_ldiv' function is fully equivalent to the body of 'oct_binop_ss_ldiv' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_mul' function is fully equivalent to the body of 'oct_binop_ssx_mul' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_div' function is fully equivalent to the body of 'oct_binop_ssx_div' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_pow' function is fully equivalent to the body of 'oct_binop_ssx_pow' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_ldiv' function is fully equivalent to the body of 'oct_binop_ssx_ldiv' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_mul' function is fully equivalent to the body of 'oct_binop_sxs_mul' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_div' function is fully equivalent to the body of 'oct_binop_sxs_div' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_pow' function is fully equivalent to the body of 'oct_binop_sxs_pow' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_ldiv' function is fully equivalent to the body of 'oct_binop_sxs_ldiv' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_mul' function is fully equivalent to the body of 'oct_binop_ssfx_mul' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_div' function is fully equivalent to the body of 'oct_binop_ssfx_div' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_pow' function is fully equivalent to the body of 'oct_binop_ssfx_pow' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_ldiv' function is fully equivalent to the body of 'oct_binop_ssfx_ldiv' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_mul' function is fully equivalent to the body of 'oct_binop_sfxs_mul' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_div' function is fully equivalent to the body of 'oct_binop_sfxs_div' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_pow' function is fully equivalent to the body of 'oct_binop_sfxs_pow' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_ldiv' function is fully equivalent to the body of 'oct_binop_sfxs_ldiv' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sm_el_mul' function is fully equivalent to the body of 'oct_binop_sm_mul' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sm_ldiv' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_smx_el_mul' function is fully equivalent to the body of 'oct_binop_smx_mul' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_smx_el_ldiv' function is fully equivalent to the body of 'oct_binop_smx_ldiv' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxm_el_mul' function is fully equivalent to the body of 'oct_binop_sxm_mul' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sxm_ldiv' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_smfx_el_mul' function is fully equivalent to the body of 'oct_binop_smfx_mul' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_smfx_el_ldiv' function is fully equivalent to the body of 'oct_binop_smfx_ldiv' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxm_el_mul' function is fully equivalent to the body of 'oct_binop_sfxm_mul' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sfxm_ldiv' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ms_el_mul' function is fully equivalent to the body of 'oct_binop_ms_mul' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ms_el_div' function is fully equivalent to the body of 'oct_binop_ms_div' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_msx_el_mul' function is fully equivalent to the body of 'oct_binop_msx_mul' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_msx_el_div' function is fully equivalent to the body of 'oct_binop_msx_div' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_mxs_el_mul' function is fully equivalent to the body of 'oct_binop_mxs_mul' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_mxs_el_div' function is fully equivalent to the body of 'oct_binop_mxs_div' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_msfx_el_mul' function is fully equivalent to the body of 'oct_binop_msfx_mul' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_msfx_el_div' function is fully equivalent to the body of 'oct_binop_msfx_div' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_mfxs_el_mul' function is fully equivalent to the body of 'oct_binop_mfxs_mul' function. | ||
op-i32-i32.cc (96) |
V524 | It is odd that the body of 'oct_binop_mfxs_el_div' function is fully equivalent to the body of 'oct_binop_mfxs_div' function. | ||
op-i64-i64.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v2.scalar_value()) < Epsilon. | ||
op-i64-i64.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v1.scalar_value()) < Epsilon. | ||
op-i64-i64.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v2.float_scalar_value()) < Epsilon. | ||
op-i64-i64.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v1.float_scalar_value()) < Epsilon. | ||
op-i64-i64.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-i64-i64.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i64-i64.cc (96) |
V550 | An odd precise comparison: v2.scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i64-i64.cc (96) |
V550 | An odd precise comparison: v1.scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i64-i64.cc (96) |
V550 | An odd precise comparison: v2.float_scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i64-i64.cc (96) |
V550 | An odd precise comparison: v1.float_scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_mul' function is fully equivalent to the body of 'oct_binop_ss_mul' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_div' function is fully equivalent to the body of 'oct_binop_ss_div' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_pow' function is fully equivalent to the body of 'oct_binop_ss_pow' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_ldiv' function is fully equivalent to the body of 'oct_binop_ss_ldiv' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_mul' function is fully equivalent to the body of 'oct_binop_ssx_mul' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_div' function is fully equivalent to the body of 'oct_binop_ssx_div' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_pow' function is fully equivalent to the body of 'oct_binop_ssx_pow' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_ldiv' function is fully equivalent to the body of 'oct_binop_ssx_ldiv' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_mul' function is fully equivalent to the body of 'oct_binop_sxs_mul' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_div' function is fully equivalent to the body of 'oct_binop_sxs_div' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_pow' function is fully equivalent to the body of 'oct_binop_sxs_pow' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_ldiv' function is fully equivalent to the body of 'oct_binop_sxs_ldiv' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_mul' function is fully equivalent to the body of 'oct_binop_ssfx_mul' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_div' function is fully equivalent to the body of 'oct_binop_ssfx_div' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_pow' function is fully equivalent to the body of 'oct_binop_ssfx_pow' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_ldiv' function is fully equivalent to the body of 'oct_binop_ssfx_ldiv' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_mul' function is fully equivalent to the body of 'oct_binop_sfxs_mul' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_div' function is fully equivalent to the body of 'oct_binop_sfxs_div' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_pow' function is fully equivalent to the body of 'oct_binop_sfxs_pow' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_ldiv' function is fully equivalent to the body of 'oct_binop_sfxs_ldiv' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sm_el_mul' function is fully equivalent to the body of 'oct_binop_sm_mul' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sm_ldiv' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_smx_el_mul' function is fully equivalent to the body of 'oct_binop_smx_mul' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_smx_el_ldiv' function is fully equivalent to the body of 'oct_binop_smx_ldiv' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxm_el_mul' function is fully equivalent to the body of 'oct_binop_sxm_mul' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sxm_ldiv' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_smfx_el_mul' function is fully equivalent to the body of 'oct_binop_smfx_mul' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_smfx_el_ldiv' function is fully equivalent to the body of 'oct_binop_smfx_ldiv' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxm_el_mul' function is fully equivalent to the body of 'oct_binop_sfxm_mul' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sfxm_ldiv' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ms_el_mul' function is fully equivalent to the body of 'oct_binop_ms_mul' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ms_el_div' function is fully equivalent to the body of 'oct_binop_ms_div' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_msx_el_mul' function is fully equivalent to the body of 'oct_binop_msx_mul' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_msx_el_div' function is fully equivalent to the body of 'oct_binop_msx_div' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_mxs_el_mul' function is fully equivalent to the body of 'oct_binop_mxs_mul' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_mxs_el_div' function is fully equivalent to the body of 'oct_binop_mxs_div' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_msfx_el_mul' function is fully equivalent to the body of 'oct_binop_msfx_mul' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_msfx_el_div' function is fully equivalent to the body of 'oct_binop_msfx_div' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_mfxs_el_mul' function is fully equivalent to the body of 'oct_binop_mfxs_mul' function. | ||
op-i64-i64.cc (96) |
V524 | It is odd that the body of 'oct_binop_mfxs_el_div' function is fully equivalent to the body of 'oct_binop_mfxs_div' function. | ||
op-i8-i8.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v2.scalar_value()) < Epsilon. | ||
op-i8-i8.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v1.scalar_value()) < Epsilon. | ||
op-i8-i8.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v2.float_scalar_value()) < Epsilon. | ||
op-i8-i8.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v1.float_scalar_value()) < Epsilon. | ||
op-i8-i8.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-i8-i8.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i8-i8.cc (96) |
V550 | An odd precise comparison: v2.scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i8-i8.cc (96) |
V550 | An odd precise comparison: v1.scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i8-i8.cc (96) |
V550 | An odd precise comparison: v2.float_scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i8-i8.cc (96) |
V550 | An odd precise comparison: v1.float_scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_mul' function is fully equivalent to the body of 'oct_binop_ss_mul' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_div' function is fully equivalent to the body of 'oct_binop_ss_div' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_pow' function is fully equivalent to the body of 'oct_binop_ss_pow' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_ldiv' function is fully equivalent to the body of 'oct_binop_ss_ldiv' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_mul' function is fully equivalent to the body of 'oct_binop_ssx_mul' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_div' function is fully equivalent to the body of 'oct_binop_ssx_div' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_pow' function is fully equivalent to the body of 'oct_binop_ssx_pow' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_ldiv' function is fully equivalent to the body of 'oct_binop_ssx_ldiv' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_mul' function is fully equivalent to the body of 'oct_binop_sxs_mul' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_div' function is fully equivalent to the body of 'oct_binop_sxs_div' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_pow' function is fully equivalent to the body of 'oct_binop_sxs_pow' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_ldiv' function is fully equivalent to the body of 'oct_binop_sxs_ldiv' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_mul' function is fully equivalent to the body of 'oct_binop_ssfx_mul' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_div' function is fully equivalent to the body of 'oct_binop_ssfx_div' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_pow' function is fully equivalent to the body of 'oct_binop_ssfx_pow' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_ldiv' function is fully equivalent to the body of 'oct_binop_ssfx_ldiv' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_mul' function is fully equivalent to the body of 'oct_binop_sfxs_mul' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_div' function is fully equivalent to the body of 'oct_binop_sfxs_div' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_pow' function is fully equivalent to the body of 'oct_binop_sfxs_pow' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_ldiv' function is fully equivalent to the body of 'oct_binop_sfxs_ldiv' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sm_el_mul' function is fully equivalent to the body of 'oct_binop_sm_mul' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sm_ldiv' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_smx_el_mul' function is fully equivalent to the body of 'oct_binop_smx_mul' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_smx_el_ldiv' function is fully equivalent to the body of 'oct_binop_smx_ldiv' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxm_el_mul' function is fully equivalent to the body of 'oct_binop_sxm_mul' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sxm_ldiv' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_smfx_el_mul' function is fully equivalent to the body of 'oct_binop_smfx_mul' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_smfx_el_ldiv' function is fully equivalent to the body of 'oct_binop_smfx_ldiv' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxm_el_mul' function is fully equivalent to the body of 'oct_binop_sfxm_mul' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sfxm_ldiv' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ms_el_mul' function is fully equivalent to the body of 'oct_binop_ms_mul' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ms_el_div' function is fully equivalent to the body of 'oct_binop_ms_div' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_msx_el_mul' function is fully equivalent to the body of 'oct_binop_msx_mul' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_msx_el_div' function is fully equivalent to the body of 'oct_binop_msx_div' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_mxs_el_mul' function is fully equivalent to the body of 'oct_binop_mxs_mul' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_mxs_el_div' function is fully equivalent to the body of 'oct_binop_mxs_div' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_msfx_el_mul' function is fully equivalent to the body of 'oct_binop_msfx_mul' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_msfx_el_div' function is fully equivalent to the body of 'oct_binop_msfx_div' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_mfxs_el_mul' function is fully equivalent to the body of 'oct_binop_mfxs_mul' function. | ||
op-i8-i8.cc (96) |
V524 | It is odd that the body of 'oct_binop_mfxs_el_div' function is fully equivalent to the body of 'oct_binop_mfxs_div' function. | ||
op-m-cs.cc (58) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-m-cs.cc (97) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-m-cs.cc (88) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-m-cs.cc (90) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-m-s.cc (52) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-m-s.cc (91) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-m-s.cc (82) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-m-s.cc (84) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-m-scm.cc (60) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-m-sm.cc (58) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-pm-sm.cc (93) |
V525 | The code contains the collection of similar blocks. Check items 'op_mul', 'op_ldiv', 'op_mul', 'op_div' in lines 93, 95, 97, 99. | ||
op-s-cm.cc (77) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-cm.cc (102) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-cm.cc (90) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-s-cm.cc (94) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-s-cs.cc (53) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-cs.cc (68) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-cs.cc (76) |
V550 | An odd precise comparison: v1.scalar_value() == v2.complex_value(). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-cs.cc (79) |
V550 | An odd precise comparison: v1.scalar_value() != v2.complex_value(). It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-s-cs.cc (90) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-cs.cc (105) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-cs.cc (116) |
V550 | An odd precise comparison: v2.complex_value() != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-s-cs.cc (124) |
V550 | An odd precise comparison: v2.complex_value() != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-s-cs.cc (81) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-s-cs.cc (83) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-s-cs.cc (96) |
V524 | It is odd that the body of 'oct_binop_el_pow' function is fully equivalent to the body of 'oct_binop_pow' function. | ||
op-s-cs.cc (98) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-s-m.cc (69) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-m.cc (93) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-m.cc (82) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-s-m.cc (86) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-s-s.cc (51) |
V550 | An odd precise comparison: x == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-s.cc (75) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-s.cc (90) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-s.cc (98) |
V550 | An odd precise comparison: v1.scalar_value() == v2.scalar_value(). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-s.cc (101) |
V550 | An odd precise comparison: v1.scalar_value() != v2.scalar_value(). It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-s-s.cc (112) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-s.cc (127) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-s.cc (103) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-s-s.cc (105) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-s-s.cc (118) |
V524 | It is odd that the body of 'oct_binop_el_pow' function is fully equivalent to the body of 'oct_binop_pow' function. | ||
op-s-s.cc (120) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-s-scm.cc (60) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-scm.cc (93) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-scm.cc (121) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-scm.cc (108) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-s-scm.cc (112) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-s-sm.cc (55) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-sm.cc (86) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-sm.cc (113) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-s-sm.cc (101) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-s-sm.cc (105) |
V524 | It is odd that the body of 'oct_binop_el_ldiv' function is fully equivalent to the body of 'oct_binop_ldiv' function. | ||
op-scm-cm.cc (80) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-scm-cs.cc (56) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-scm-cs.cc (82) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-scm-cs.cc (117) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-scm-cs.cc (105) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-scm-m.cc (79) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-scm-s.cc (59) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-scm-s.cc (90) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-scm-s.cc (124) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-scm-s.cc (113) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-scm-s.cc (115) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-scm-scm.cc (109) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-scm-scm.cc (141) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-scm-sm.cc (59) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-scm-sm.cc (91) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-sm-cm.cc (80) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-sm-cs.cc (57) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-sm-cs.cc (81) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-sm-cs.cc (114) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-sm-cs.cc (104) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-sm-cs.cc (106) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-sm-m.cc (75) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-sm-s.cc (54) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-sm-s.cc (83) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-sm-s.cc (116) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-sm-s.cc (106) |
V524 | It is odd that the body of 'oct_binop_el_mul' function is fully equivalent to the body of 'oct_binop_mul' function. | ||
op-sm-s.cc (108) |
V524 | It is odd that the body of 'oct_binop_el_div' function is fully equivalent to the body of 'oct_binop_div' function. | ||
op-sm-scm.cc (59) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-sm-scm.cc (91) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-sm-sm.cc (82) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-sm-sm.cc (112) |
V550 | An odd precise comparison: d == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-ui16-ui16.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v2.scalar_value()) < Epsilon. | ||
op-ui16-ui16.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v1.scalar_value()) < Epsilon. | ||
op-ui16-ui16.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v2.float_scalar_value()) < Epsilon. | ||
op-ui16-ui16.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v1.float_scalar_value()) < Epsilon. | ||
op-ui16-ui16.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-ui16-ui16.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui16-ui16.cc (96) |
V550 | An odd precise comparison: v2.scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui16-ui16.cc (96) |
V550 | An odd precise comparison: v1.scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui16-ui16.cc (96) |
V550 | An odd precise comparison: v2.float_scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui16-ui16.cc (96) |
V550 | An odd precise comparison: v1.float_scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_mul' function is fully equivalent to the body of 'oct_binop_ss_mul' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_div' function is fully equivalent to the body of 'oct_binop_ss_div' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_pow' function is fully equivalent to the body of 'oct_binop_ss_pow' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_ldiv' function is fully equivalent to the body of 'oct_binop_ss_ldiv' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_mul' function is fully equivalent to the body of 'oct_binop_ssx_mul' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_div' function is fully equivalent to the body of 'oct_binop_ssx_div' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_pow' function is fully equivalent to the body of 'oct_binop_ssx_pow' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_ldiv' function is fully equivalent to the body of 'oct_binop_ssx_ldiv' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_mul' function is fully equivalent to the body of 'oct_binop_sxs_mul' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_div' function is fully equivalent to the body of 'oct_binop_sxs_div' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_pow' function is fully equivalent to the body of 'oct_binop_sxs_pow' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_ldiv' function is fully equivalent to the body of 'oct_binop_sxs_ldiv' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_mul' function is fully equivalent to the body of 'oct_binop_ssfx_mul' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_div' function is fully equivalent to the body of 'oct_binop_ssfx_div' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_pow' function is fully equivalent to the body of 'oct_binop_ssfx_pow' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_ldiv' function is fully equivalent to the body of 'oct_binop_ssfx_ldiv' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_mul' function is fully equivalent to the body of 'oct_binop_sfxs_mul' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_div' function is fully equivalent to the body of 'oct_binop_sfxs_div' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_pow' function is fully equivalent to the body of 'oct_binop_sfxs_pow' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_ldiv' function is fully equivalent to the body of 'oct_binop_sfxs_ldiv' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sm_el_mul' function is fully equivalent to the body of 'oct_binop_sm_mul' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sm_ldiv' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_smx_el_mul' function is fully equivalent to the body of 'oct_binop_smx_mul' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_smx_el_ldiv' function is fully equivalent to the body of 'oct_binop_smx_ldiv' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxm_el_mul' function is fully equivalent to the body of 'oct_binop_sxm_mul' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sxm_ldiv' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_smfx_el_mul' function is fully equivalent to the body of 'oct_binop_smfx_mul' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_smfx_el_ldiv' function is fully equivalent to the body of 'oct_binop_smfx_ldiv' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxm_el_mul' function is fully equivalent to the body of 'oct_binop_sfxm_mul' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sfxm_ldiv' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ms_el_mul' function is fully equivalent to the body of 'oct_binop_ms_mul' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_ms_el_div' function is fully equivalent to the body of 'oct_binop_ms_div' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_msx_el_mul' function is fully equivalent to the body of 'oct_binop_msx_mul' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_msx_el_div' function is fully equivalent to the body of 'oct_binop_msx_div' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_mxs_el_mul' function is fully equivalent to the body of 'oct_binop_mxs_mul' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_mxs_el_div' function is fully equivalent to the body of 'oct_binop_mxs_div' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_msfx_el_mul' function is fully equivalent to the body of 'oct_binop_msfx_mul' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_msfx_el_div' function is fully equivalent to the body of 'oct_binop_msfx_div' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_mfxs_el_mul' function is fully equivalent to the body of 'oct_binop_mfxs_mul' function. | ||
op-ui16-ui16.cc (96) |
V524 | It is odd that the body of 'oct_binop_mfxs_el_div' function is fully equivalent to the body of 'oct_binop_mfxs_div' function. | ||
op-ui32-ui32.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v2.scalar_value()) < Epsilon. | ||
op-ui32-ui32.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v1.scalar_value()) < Epsilon. | ||
op-ui32-ui32.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v2.float_scalar_value()) < Epsilon. | ||
op-ui32-ui32.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v1.float_scalar_value()) < Epsilon. | ||
op-ui32-ui32.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-ui32-ui32.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui32-ui32.cc (96) |
V550 | An odd precise comparison: v2.scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui32-ui32.cc (96) |
V550 | An odd precise comparison: v1.scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui32-ui32.cc (96) |
V550 | An odd precise comparison: v2.float_scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui32-ui32.cc (96) |
V550 | An odd precise comparison: v1.float_scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_mul' function is fully equivalent to the body of 'oct_binop_ss_mul' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_div' function is fully equivalent to the body of 'oct_binop_ss_div' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_pow' function is fully equivalent to the body of 'oct_binop_ss_pow' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_ldiv' function is fully equivalent to the body of 'oct_binop_ss_ldiv' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_mul' function is fully equivalent to the body of 'oct_binop_ssx_mul' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_div' function is fully equivalent to the body of 'oct_binop_ssx_div' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_pow' function is fully equivalent to the body of 'oct_binop_ssx_pow' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_ldiv' function is fully equivalent to the body of 'oct_binop_ssx_ldiv' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_mul' function is fully equivalent to the body of 'oct_binop_sxs_mul' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_div' function is fully equivalent to the body of 'oct_binop_sxs_div' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_pow' function is fully equivalent to the body of 'oct_binop_sxs_pow' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_ldiv' function is fully equivalent to the body of 'oct_binop_sxs_ldiv' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_mul' function is fully equivalent to the body of 'oct_binop_ssfx_mul' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_div' function is fully equivalent to the body of 'oct_binop_ssfx_div' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_pow' function is fully equivalent to the body of 'oct_binop_ssfx_pow' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_ldiv' function is fully equivalent to the body of 'oct_binop_ssfx_ldiv' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_mul' function is fully equivalent to the body of 'oct_binop_sfxs_mul' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_div' function is fully equivalent to the body of 'oct_binop_sfxs_div' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_pow' function is fully equivalent to the body of 'oct_binop_sfxs_pow' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_ldiv' function is fully equivalent to the body of 'oct_binop_sfxs_ldiv' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sm_el_mul' function is fully equivalent to the body of 'oct_binop_sm_mul' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sm_ldiv' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_smx_el_mul' function is fully equivalent to the body of 'oct_binop_smx_mul' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_smx_el_ldiv' function is fully equivalent to the body of 'oct_binop_smx_ldiv' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxm_el_mul' function is fully equivalent to the body of 'oct_binop_sxm_mul' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sxm_ldiv' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_smfx_el_mul' function is fully equivalent to the body of 'oct_binop_smfx_mul' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_smfx_el_ldiv' function is fully equivalent to the body of 'oct_binop_smfx_ldiv' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxm_el_mul' function is fully equivalent to the body of 'oct_binop_sfxm_mul' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sfxm_ldiv' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ms_el_mul' function is fully equivalent to the body of 'oct_binop_ms_mul' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_ms_el_div' function is fully equivalent to the body of 'oct_binop_ms_div' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_msx_el_mul' function is fully equivalent to the body of 'oct_binop_msx_mul' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_msx_el_div' function is fully equivalent to the body of 'oct_binop_msx_div' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_mxs_el_mul' function is fully equivalent to the body of 'oct_binop_mxs_mul' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_mxs_el_div' function is fully equivalent to the body of 'oct_binop_mxs_div' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_msfx_el_mul' function is fully equivalent to the body of 'oct_binop_msfx_mul' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_msfx_el_div' function is fully equivalent to the body of 'oct_binop_msfx_div' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_mfxs_el_mul' function is fully equivalent to the body of 'oct_binop_mfxs_mul' function. | ||
op-ui32-ui32.cc (96) |
V524 | It is odd that the body of 'oct_binop_mfxs_el_div' function is fully equivalent to the body of 'oct_binop_mfxs_div' function. | ||
op-ui64-ui64.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v2.scalar_value()) < Epsilon. | ||
op-ui64-ui64.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v1.scalar_value()) < Epsilon. | ||
op-ui64-ui64.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v2.float_scalar_value()) < Epsilon. | ||
op-ui64-ui64.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v1.float_scalar_value()) < Epsilon. | ||
op-ui64-ui64.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-ui64-ui64.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui64-ui64.cc (96) |
V550 | An odd precise comparison: v2.scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui64-ui64.cc (96) |
V550 | An odd precise comparison: v1.scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui64-ui64.cc (96) |
V550 | An odd precise comparison: v2.float_scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui64-ui64.cc (96) |
V550 | An odd precise comparison: v1.float_scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_mul' function is fully equivalent to the body of 'oct_binop_ss_mul' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_div' function is fully equivalent to the body of 'oct_binop_ss_div' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_pow' function is fully equivalent to the body of 'oct_binop_ss_pow' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_ldiv' function is fully equivalent to the body of 'oct_binop_ss_ldiv' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_mul' function is fully equivalent to the body of 'oct_binop_ssx_mul' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_div' function is fully equivalent to the body of 'oct_binop_ssx_div' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_pow' function is fully equivalent to the body of 'oct_binop_ssx_pow' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_ldiv' function is fully equivalent to the body of 'oct_binop_ssx_ldiv' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_mul' function is fully equivalent to the body of 'oct_binop_sxs_mul' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_div' function is fully equivalent to the body of 'oct_binop_sxs_div' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_pow' function is fully equivalent to the body of 'oct_binop_sxs_pow' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_ldiv' function is fully equivalent to the body of 'oct_binop_sxs_ldiv' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_mul' function is fully equivalent to the body of 'oct_binop_ssfx_mul' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_div' function is fully equivalent to the body of 'oct_binop_ssfx_div' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_pow' function is fully equivalent to the body of 'oct_binop_ssfx_pow' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_ldiv' function is fully equivalent to the body of 'oct_binop_ssfx_ldiv' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_mul' function is fully equivalent to the body of 'oct_binop_sfxs_mul' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_div' function is fully equivalent to the body of 'oct_binop_sfxs_div' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_pow' function is fully equivalent to the body of 'oct_binop_sfxs_pow' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_ldiv' function is fully equivalent to the body of 'oct_binop_sfxs_ldiv' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sm_el_mul' function is fully equivalent to the body of 'oct_binop_sm_mul' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sm_ldiv' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_smx_el_mul' function is fully equivalent to the body of 'oct_binop_smx_mul' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_smx_el_ldiv' function is fully equivalent to the body of 'oct_binop_smx_ldiv' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxm_el_mul' function is fully equivalent to the body of 'oct_binop_sxm_mul' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sxm_ldiv' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_smfx_el_mul' function is fully equivalent to the body of 'oct_binop_smfx_mul' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_smfx_el_ldiv' function is fully equivalent to the body of 'oct_binop_smfx_ldiv' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxm_el_mul' function is fully equivalent to the body of 'oct_binop_sfxm_mul' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sfxm_ldiv' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ms_el_mul' function is fully equivalent to the body of 'oct_binop_ms_mul' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_ms_el_div' function is fully equivalent to the body of 'oct_binop_ms_div' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_msx_el_mul' function is fully equivalent to the body of 'oct_binop_msx_mul' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_msx_el_div' function is fully equivalent to the body of 'oct_binop_msx_div' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_mxs_el_mul' function is fully equivalent to the body of 'oct_binop_mxs_mul' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_mxs_el_div' function is fully equivalent to the body of 'oct_binop_mxs_div' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_msfx_el_mul' function is fully equivalent to the body of 'oct_binop_msfx_mul' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_msfx_el_div' function is fully equivalent to the body of 'oct_binop_msfx_div' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_mfxs_el_mul' function is fully equivalent to the body of 'oct_binop_mfxs_mul' function. | ||
op-ui64-ui64.cc (96) |
V524 | It is odd that the body of 'oct_binop_mfxs_el_div' function is fully equivalent to the body of 'oct_binop_mfxs_div' function. | ||
op-ui8-ui8.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v2.scalar_value()) < Epsilon. | ||
op-ui8-ui8.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v1.scalar_value()) < Epsilon. | ||
op-ui8-ui8.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v2.float_scalar_value()) < Epsilon. | ||
op-ui8-ui8.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(v1.float_scalar_value()) < Epsilon. | ||
op-ui8-ui8.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
op-ui8-ui8.cc (96) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui8-ui8.cc (96) |
V550 | An odd precise comparison: v2.scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui8-ui8.cc (96) |
V550 | An odd precise comparison: v1.scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui8-ui8.cc (96) |
V550 | An odd precise comparison: v2.float_scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui8-ui8.cc (96) |
V550 | An odd precise comparison: v1.float_scalar_value() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_mul' function is fully equivalent to the body of 'oct_binop_ss_mul' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_div' function is fully equivalent to the body of 'oct_binop_ss_div' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_pow' function is fully equivalent to the body of 'oct_binop_ss_pow' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ss_el_ldiv' function is fully equivalent to the body of 'oct_binop_ss_ldiv' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_mul' function is fully equivalent to the body of 'oct_binop_ssx_mul' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_div' function is fully equivalent to the body of 'oct_binop_ssx_div' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_pow' function is fully equivalent to the body of 'oct_binop_ssx_pow' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssx_el_ldiv' function is fully equivalent to the body of 'oct_binop_ssx_ldiv' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_mul' function is fully equivalent to the body of 'oct_binop_sxs_mul' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_div' function is fully equivalent to the body of 'oct_binop_sxs_div' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_pow' function is fully equivalent to the body of 'oct_binop_sxs_pow' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxs_el_ldiv' function is fully equivalent to the body of 'oct_binop_sxs_ldiv' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_mul' function is fully equivalent to the body of 'oct_binop_ssfx_mul' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_div' function is fully equivalent to the body of 'oct_binop_ssfx_div' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_pow' function is fully equivalent to the body of 'oct_binop_ssfx_pow' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ssfx_el_ldiv' function is fully equivalent to the body of 'oct_binop_ssfx_ldiv' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_mul' function is fully equivalent to the body of 'oct_binop_sfxs_mul' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_div' function is fully equivalent to the body of 'oct_binop_sfxs_div' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_pow' function is fully equivalent to the body of 'oct_binop_sfxs_pow' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxs_el_ldiv' function is fully equivalent to the body of 'oct_binop_sfxs_ldiv' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sm_el_mul' function is fully equivalent to the body of 'oct_binop_sm_mul' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sm_ldiv' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_smx_el_mul' function is fully equivalent to the body of 'oct_binop_smx_mul' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_smx_el_ldiv' function is fully equivalent to the body of 'oct_binop_smx_ldiv' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxm_el_mul' function is fully equivalent to the body of 'oct_binop_sxm_mul' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sxm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sxm_ldiv' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_smfx_el_mul' function is fully equivalent to the body of 'oct_binop_smfx_mul' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_smfx_el_ldiv' function is fully equivalent to the body of 'oct_binop_smfx_ldiv' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxm_el_mul' function is fully equivalent to the body of 'oct_binop_sfxm_mul' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_sfxm_el_ldiv' function is fully equivalent to the body of 'oct_binop_sfxm_ldiv' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ms_el_mul' function is fully equivalent to the body of 'oct_binop_ms_mul' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_ms_el_div' function is fully equivalent to the body of 'oct_binop_ms_div' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_msx_el_mul' function is fully equivalent to the body of 'oct_binop_msx_mul' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_msx_el_div' function is fully equivalent to the body of 'oct_binop_msx_div' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_mxs_el_mul' function is fully equivalent to the body of 'oct_binop_mxs_mul' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_mxs_el_div' function is fully equivalent to the body of 'oct_binop_mxs_div' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_msfx_el_mul' function is fully equivalent to the body of 'oct_binop_msfx_mul' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_msfx_el_div' function is fully equivalent to the body of 'oct_binop_msfx_div' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_mfxs_el_mul' function is fully equivalent to the body of 'oct_binop_mfxs_mul' function. | ||
op-ui8-ui8.cc (96) |
V524 | It is odd that the body of 'oct_binop_mfxs_el_div' function is fully equivalent to the body of 'oct_binop_mfxs_div' function. | ||
Array.cc (2697) |
V1028 | Possible overflow. Consider casting operands of the 'dim + 1' operator to the 'octave_idx_type' type, not the result. | ||
oct-sort.cc (656) |
V602 | Consider inspecting the '(min_gallop > 1)' expression. '>' possibly should be replaced with '>>'. | ||
oct-sort.cc (790) |
V602 | Consider inspecting the '(min_gallop > 1)' expression. '>' possibly should be replaced with '>>'. | ||
oct-sort.cc (938) |
V602 | Consider inspecting the '(min_gallop > 1)' expression. '>' possibly should be replaced with '>>'. | ||
oct-sort.cc (1079) |
V602 | Consider inspecting the '(min_gallop > 1)' expression. '>' possibly should be replaced with '>>'. | ||
oct-errno.cc (702) |
V668 | There is no sense in testing the 'instance' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
singleton-cleanup.h (64) |
V524 | It is odd that the body of 'cleanup_instance' function is fully equivalent to the body of 'cleanup' function. | ||
ov-base.cc (489) |
V550 | An odd precise comparison: octave::math::x_nint(d) != d. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-base.cc (490) |
V550 | An odd precise comparison: octave::math::x_nint(d) != d. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-base.cc (492) |
V550 | An odd precise comparison: octave::math::x_nint(d) != d. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-base.cc (493) |
V550 | An odd precise comparison: octave::math::x_nint(d) != d. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-base.cc (495) |
V550 | An odd precise comparison: octave::math::x_nint(d) != d. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-base.cc (496) |
V550 | An odd precise comparison: octave::math::x_nint(d) != d. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-base.cc (498) |
V550 | An odd precise comparison: octave::math::x_nint(d) != d. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-base.cc (499) |
V550 | An odd precise comparison: octave::math::x_nint(d) != d. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-base.cc (1091) |
V1016 | Expression 'umap < 0' is always false. | ||
ov-bool-mat.cc (317) |
V547 | Expression '!extract_keyword(is, "columns", nc)' is always false. | ||
ov-bool-mat.cc (317) |
V560 | A part of conditional expression is always false: nc < 0. | ||
ov-bool-mat.cc (320) |
V560 | A part of conditional expression is always false: nc > 0. | ||
ov-bool-mat.cc (334) |
V560 | A part of conditional expression is always true: nc == 0. | ||
ov-base-mat.h (68) |
V773 | The 'typ' pointer was not released in destructor. A memory leak is possible. | ||
ov-bool.cc (65) |
V601 | The bool type is implicitly cast to the double type. Inspect the first argument. | ||
ov-bool.cc (197) |
V550 | An odd precise comparison: octave_read_value <double> (is) != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-bool.cc (237) |
V614 | Uninitialized buffer 'dimens' used. Consider checking the second actual argument of the 'H5Screate_simple' function. | ||
ov-bool.cc (237) |
V519 | The 'space_hid' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 235, 237. | ||
ov-bool.cc (297) |
V550 | An odd precise comparison: dtmp != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-cell.cc (847) |
V547 | Expression '!extract_keyword(is, "columns", nc)' is always false. | ||
ov-cell.cc (847) |
V560 | A part of conditional expression is always false: nc < 0. | ||
ov-cell.cc (850) |
V560 | A part of conditional expression is always false: nc > 0. | ||
ov-cell.cc (878) |
V560 | A part of conditional expression is always true: nc == 0. | ||
ov-cell.cc (890) |
V669 | The 'save_as_floats' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
ov-class.cc (1216) |
V547 | Expression '!extract_keyword(is, "length", len)' is always false. | ||
ov-class.cc (1216) |
V560 | A part of conditional expression is always false: len < 0. | ||
ov-class.cc (1261) |
V547 | Expression 'len == 0' is always true. | ||
ov-class.cc (1219) |
V547 | Expression 'len > 0' is always false. | ||
ov-class.cc (1273) |
V669 | The 'save_as_floats' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
ov-class.cc (1480) |
V525 | The code contains the collection of similar blocks. Check items 'H5Gclose', 'H5Dclose', 'H5Sclose', 'H5Tclose', 'H5Gclose' in lines 1480, 1483, 1486, 1489, 1492. | ||
ov-classdef.cc (1220) |
V522 | There might be dereferencing of a potential null pointer 'of'. | ||
ov-classdef.cc (2417) |
V783 | Dereferencing of the invalid iterator '++ (idx.begin())' might take place. | ||
ov-classdef.cc (3485) |
V678 | An object is used as an argument to its own method. Consider checking the first actual argument of the 'set_class' function. | ||
ov-colon.h (44) |
V690 | The 'octave_magic_colon' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-complex.cc (114) |
V550 | An odd precise comparison: im == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ov-complex.cc (368) |
V614 | Uninitialized buffer 'dimens' used. Consider checking the second actual argument of the 'H5Screate_simple' function. | ||
ov-complex.cc (368) |
V519 | The 'space_hid' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 366, 368. | ||
ov-cs-list.h (43) |
V690 | The 'octave_cs_list' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-cx-diag.cc (180) |
V669 | The 'save_as_floats' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
ov-cx-mat.cc (95) |
V550 | An odd precise comparison: c.imag() == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ov-cx-mat.cc (389) |
V547 | Expression '!extract_keyword(is, "columns", nc)' is always false. | ||
ov-cx-mat.cc (389) |
V560 | A part of conditional expression is always false: nc < 0. | ||
ov-cx-mat.cc (392) |
V560 | A part of conditional expression is always false: nc > 0. | ||
ov-cx-mat.cc (401) |
V560 | A part of conditional expression is always true: nc == 0. | ||
ov-cx-mat.cc (413) |
V669 | The 'save_as_floats' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
ov-fcn-handle.cc (538) |
V669 | The 'save_as_floats' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
ov-fcn-handle.cc (780) |
V547 | Expression 'type_hid < 0' is always false. | ||
ov-fcn-handle.cc (735) |
V519 | The 'type_hid' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 732, 735. | ||
ov-fcn-handle.cc (1748) |
V1004 | The 'fh' pointer was used unsafely after it was verified against nullptr. Check lines: 1741, 1748. | ||
ov-fcn-handle.cc (1989) |
V522 | There might be dereferencing of a potential null pointer 'idx_expr'. | ||
ov-fcn-handle.cc (2046) |
V522 | There might be dereferencing of a potential null pointer 'elt_id'. | ||
ov-fcn-handle.cc (2073) |
V522 | There might be dereferencing of a potential null pointer 'head_id'. | ||
ov-fcn-inline.h (39) |
V690 | The 'octave_fcn_inline' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-fcn-inline.cc (399) |
V547 | Expression 'type_hid < 0' is always false. | ||
ov-fcn-inline.cc (491) |
V767 | Suspicious access to element of 'hdims' array by a constant index inside a loop. | ||
ov-fcn-inline.cc (986) |
V522 | There might be dereferencing of a potential null pointer 'old'. | ||
ov-float.cc (258) |
V614 | Uninitialized buffer 'dimens' used. Consider checking the second actual argument of the 'H5Screate_simple' function. | ||
ov-float.cc (258) |
V519 | The 'space_hid' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 256, 258. | ||
ov-flt-complex.cc (70) |
V550 | An odd precise comparison: im == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ov-flt-complex.cc (315) |
V614 | Uninitialized buffer 'dimens' used. Consider checking the second actual argument of the 'H5Screate_simple' function. | ||
ov-flt-complex.cc (315) |
V519 | The 'space_hid' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 313, 315. | ||
ov-flt-cx-mat.cc (83) |
V550 | An odd precise comparison: c.imag() == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ov-flt-cx-mat.cc (363) |
V547 | Expression '!extract_keyword(is, "columns", nc)' is always false. | ||
ov-flt-cx-mat.cc (363) |
V560 | A part of conditional expression is always false: nc < 0. | ||
ov-flt-cx-mat.cc (366) |
V560 | A part of conditional expression is always false: nc > 0. | ||
ov-flt-cx-mat.cc (375) |
V560 | A part of conditional expression is always true: nc == 0. | ||
ov-flt-cx-mat.cc (556) |
V547 | Expression 'retval' is always false. | ||
ov-flt-re-mat.cc (440) |
V547 | Expression '!extract_keyword(is, "columns", nc)' is always false. | ||
ov-flt-re-mat.cc (440) |
V560 | A part of conditional expression is always false: nc < 0. | ||
ov-flt-re-mat.cc (443) |
V560 | A part of conditional expression is always false: nc > 0. | ||
ov-flt-re-mat.cc (452) |
V560 | A part of conditional expression is always true: nc == 0. | ||
ov-flt-re-mat.cc (748) |
V550 | An odd precise comparison: tmp.imag() == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ov-flt-re-mat.cc (738) |
V669 | The 'fcn' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
ov-java.h (38) |
V690 | The 'octave_java' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-lazy-idx.h (33) |
V690 | The 'octave_lazy_index' class implements a copy constructor, but lacks the '=' operator. It is dangerous to use such a class. | ||
ov-lazy-idx.cc (240) |
V669 | The 'save_as_floats' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
ov-range.cc (481) |
V550 | An odd precise comparison: range.inc() != 1. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-range.cc (530) |
V550 | An odd precise comparison: inc != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-range.cc (537) |
V550 | An odd precise comparison: inc != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-range.cc (560) |
V550 | An odd precise comparison: inc != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-range.cc (577) |
V550 | An odd precise comparison: inc == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ov-range.cc (607) |
V550 | An odd precise comparison: inc != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-range.cc (649) |
V614 | Uninitialized buffer 'dimens' used. Consider checking the second actual argument of the 'H5Screate_simple' function. | ||
ov-range.cc (674) |
V550 | An odd precise comparison: r.inc() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-range.cc (649) |
V519 | The 'space_hid' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 647, 649. | ||
ov-range.cc (748) |
V550 | An odd precise comparison: rangevals[2] != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-re-diag.cc (246) |
V669 | The 'save_as_floats' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
ov-re-mat.cc (543) |
V547 | Expression '!extract_keyword(is, "columns", nc)' is always false. | ||
ov-re-mat.cc (543) |
V560 | A part of conditional expression is always false: nc < 0. | ||
ov-re-mat.cc (546) |
V560 | A part of conditional expression is always false: nc > 0. | ||
ov-re-mat.cc (555) |
V560 | A part of conditional expression is always true: nc == 0. | ||
ov-re-mat.cc (567) |
V669 | The 'save_as_floats' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
ov-re-mat.cc (875) |
V550 | An odd precise comparison: tmp.imag() == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ov-re-mat.cc (865) |
V669 | The 'fcn' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
ov-scalar.cc (278) |
V614 | Uninitialized buffer 'dimens' used. Consider checking the second actual argument of the 'H5Screate_simple' function. | ||
ov-scalar.cc (278) |
V519 | The 'space_hid' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 276, 278. | ||
ov-str-mat.cc (404) |
V614 | Uninitialized variable 'len' used. Consider checking the third actual argument of the 'extract_keyword' function. | ||
ov-str-mat.cc (404) |
V547 | Expression '!extract_keyword(is, "length", len)' is always false. | ||
ov-struct.cc (785) |
V547 | Expression 'len == 0' is always true. | ||
ov-struct.cc (794) |
V669 | The 'save_as_floats' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
ov-struct.cc (1418) |
V547 | Expression '!extract_keyword(is, "length", len)' is always false. | ||
ov-struct.cc (1418) |
V560 | A part of conditional expression is always false: len < 0. | ||
ov-struct.cc (1445) |
V547 | Expression 'len == 0' is always true. | ||
ov-struct.cc (1421) |
V547 | Expression 'len > 0' is always false. | ||
ov-struct.cc (1454) |
V669 | The 'save_as_floats' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
ov-usr-fcn.cc (827) |
V550 | An odd precise comparison: k != octave::math::fix(k). It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
ov-usr-fcn.cc (830) |
V550 | An odd precise comparison: k == 1. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ov.cc (1824) |
V550 | An odd precise comparison: ai == v. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ov.cc (1894) |
V550 | An odd precise comparison: ai == v. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ov-base-int.cc (744) |
V614 | Uninitialized buffer 'dimens' used. Consider checking the second actual argument of the 'H5Screate_simple' function. | ||
ov-base-int.cc (744) |
V519 | The 'space_hid' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 742, 744. | ||
ov-base-sparse.cc (388) |
V550 | An odd precise comparison: pct == 100. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ov-bool-sparse.cc (359) |
V614 | Uninitialized buffer 'hdims' used. Consider checking the second actual argument of the 'H5Screate_simple' function. | ||
ov-cx-sparse.cc (78) |
V550 | An odd precise comparison: c.imag() == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ov-cx-sparse.cc (222) |
V669 | The 'save_as_floats' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
ov-cx-sparse.cc (391) |
V614 | Uninitialized buffer 'hdims' used. Consider checking the second actual argument of the 'H5Screate_simple' function. | ||
ov-re-sparse.cc (247) |
V669 | The 'save_as_floats' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
ov-re-sparse.cc (414) |
V614 | Uninitialized buffer 'hdims' used. Consider checking the second actual argument of the 'H5Screate_simple' function. | ||
bp-table.cc (444) |
V522 | There might be dereferencing of a potential null pointer 'stop_flag'. | ||
bp-table.cc (333) |
V547 | Expression 'seen_if' is always false. | ||
bp-table.cc (347) |
V547 | Expression 'seen_if' is always false. | ||
bp-table.cc (535) |
V522 | There might be dereferencing of a potential null pointer. | ||
bp-table.cc (587) |
V783 | Dereferencing of the invalid iterator 'ret_one.find(i)' might take place. | ||
pt-cbinop.h (68) |
V703 | It is odd that the 'm_lhs' field in derived class 'tree_compound_binary_expression' overwrites field in base class 'tree_binary_expression'. Check lines: pt-cbinop.h:68, pt-binop.h:121. | ||
pt-cbinop.h (69) |
V703 | It is odd that the 'm_rhs' field in derived class 'tree_compound_binary_expression' overwrites field in base class 'tree_binary_expression'. Check lines: pt-cbinop.h:69, pt-binop.h:122. | ||
lex.ll (391) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 391, 391. | ||
lex.ll (406) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 406, 406. | ||
lex.ll (422) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 422, 422. | ||
lex.ll (490) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 490, 490. | ||
lex.ll (584) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 584, 584. | ||
lex.ll (641) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 641, 641. | ||
lex.ll (716) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 716, 716. | ||
lex.ll (775) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 775, 775. | ||
lex.ll (1106) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1106, 1106. | ||
lex.ll (1120) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1120, 1120. | ||
lex.ll (1132) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1132, 1132. | ||
lex.ll (1157) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1157, 1157. | ||
lex.ll (1169) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1169, 1169. | ||
lex.ll (1241) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1241, 1241. | ||
lex.ll (1245) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1245, 1245. | ||
lex.ll (1257) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1257, 1257. | ||
lex.ll (1283) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1283, 1283. | ||
lex.ll (1305) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1305, 1305. | ||
lex.ll (1317) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1317, 1317. | ||
lex.ll (1416) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1416, 1416. | ||
lex.ll (1486) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1486, 1486. | ||
lex.ll (1510) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1510, 1510. | ||
lex.ll (1511) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1511, 1511. | ||
lex.ll (1512) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1512, 1512. | ||
lex.ll (1513) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1513, 1513. | ||
lex.ll (1514) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1514, 1514. | ||
lex.ll (1515) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1515, 1515. | ||
lex.ll (1516) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1516, 1516. | ||
lex.ll (1517) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1517, 1517. | ||
lex.ll (1518) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1518, 1518. | ||
lex.ll (1519) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1519, 1519. | ||
lex.ll (1520) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1520, 1520. | ||
lex.ll (1521) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1521, 1521. | ||
lex.ll (1522) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1522, 1522. | ||
lex.ll (1523) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1523, 1523. | ||
lex.ll (1524) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1524, 1524. | ||
lex.ll (1525) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1525, 1525. | ||
lex.ll (1526) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1526, 1526. | ||
lex.ll (1527) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1527, 1527. | ||
lex.ll (1528) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1528, 1528. | ||
lex.ll (1536) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1536, 1536. | ||
lex.ll (1537) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1537, 1537. | ||
lex.ll (1538) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1538, 1538. | ||
lex.ll (1539) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1539, 1539. | ||
lex.ll (1549) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1549, 1549. | ||
lex.ll (1550) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1550, 1550. | ||
lex.ll (1552) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1552, 1552. | ||
lex.ll (1553) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1553, 1553. | ||
lex.ll (1567) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1567, 1567. | ||
lex.ll (1568) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1568, 1568. | ||
lex.ll (1587) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1587, 1587. | ||
lex.ll (1639) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1639, 1639. | ||
lex.ll (1661) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1661, 1661. | ||
lex.ll (1662) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1662, 1662. | ||
lex.ll (1663) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1663, 1663. | ||
lex.ll (1664) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1664, 1664. | ||
lex.ll (1665) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1665, 1665. | ||
lex.ll (1666) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1666, 1666. | ||
lex.ll (1667) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1667, 1667. | ||
lex.ll (1668) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1668, 1668. | ||
lex.ll (1669) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1669, 1669. | ||
lex.ll (1670) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1670, 1670. | ||
lex.ll (1671) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1671, 1671. | ||
lex.ll (1672) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1672, 1672. | ||
lex.ll (1673) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1673, 1673. | ||
lex.ll (1674) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1674, 1674. | ||
lex.ll (1675) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1675, 1675. | ||
lex.ll (1676) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1676, 1676. | ||
lex.ll (1699) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1699, 1699. | ||
lex.ll (1151) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 1151, 1151. | ||
lex.ll (1151) |
V796 | It is possible that 'break' statement is missing in switch statement. | ||
lex.cc (1485) |
V553 | The length of 'octave_lex' function's body is more than 2000 lines long. You should consider refactoring the code. | ||
lex.cc (3629) |
V1004 | The 'b->yy_ch_buf' pointer was used unsafely after it was verified against nullptr. Check lines: 3625, 3629. | ||
lex.cc (3619) |
V1028 | Possible overflow. Consider casting operands of the 'b->yy_buf_size + 2' operator to the 'yy_size_t' type, not the result. | ||
lex.cc (3839) |
V779 | Unreachable code detected. It is possible that an error is present. | ||
lex.cc (3909) |
V1004 | The 'yyg->yy_buffer_stack' pointer was used unsafely after it was verified against nullptr. Check lines: 3898, 3909. | ||
lex.cc (3943) |
V1004 | The 'b' pointer was used unsafely after it was verified against nullptr. Check lines: 3940, 3943. | ||
lex.cc (3948) |
V1028 | Possible overflow. Consider casting operands of the 'b->yy_buf_size + 2' operator to the 'yy_size_t' type, not the result. | ||
lex.cc (4062) |
V1004 | The 'yyg->yy_buffer_stack' pointer was used unsafely after it was verified against nullptr. Check lines: 4051, 4062. | ||
lex.cc (4080) |
V1004 | The 'yyg->yy_buffer_stack' pointer was used unsafely after it was verified against nullptr. Check lines: 4076, 4080. | ||
lex.cc (4111) |
V1004 | The 'yyg->yy_buffer_stack' pointer was used unsafely after it was verified against nullptr. Check lines: 4108, 4111. | ||
lex.cc (4157) |
V1004 | The 'b' pointer was used unsafely after it was verified against nullptr. Check lines: 4154, 4157. | ||
lex.cc (4201) |
V1028 | Possible overflow. Consider casting operands of the '_yybytes_len + 2' operator to the 'yy_size_t' type, not the result. | ||
lex.cc (4209) |
V1004 | The 'buf' pointer was used unsafely after it was verified against nullptr. Check lines: 4203, 4209. | ||
lex.cc (4218) |
V1004 | The 'b' pointer was used unsafely after it was verified against nullptr. Check lines: 4212, 4218. | ||
lex.cc (4273) |
V1004 | The 'yyg->yy_buffer_stack' pointer was used unsafely after it was verified against nullptr. Check lines: 4270, 4273. | ||
lex.cc (4286) |
V1004 | The 'yyg->yy_buffer_stack' pointer was used unsafely after it was verified against nullptr. Check lines: 4283, 4286. | ||
lex.cc (4348) |
V1004 | The 'yyg->yy_buffer_stack' pointer was used unsafely after it was verified against nullptr. Check lines: 4345, 4348. | ||
lex.cc (4363) |
V1004 | The 'yyg->yy_buffer_stack' pointer was used unsafely after it was verified against nullptr. Check lines: 4360, 4363. | ||
lex.ll (2796) |
V576 | Incorrect format. Consider checking the third actual argument of the 'sscanf' function. A pointer to the uintmax_t type is expected. | ||
lex.cc (389) |
V1003 | The macro 'YY_STATE_EOF' is a dangerous expression. The parameter 'state' must be surrounded by parentheses. | ||
oct-parse.cc (3048) |
V553 | The length of 'octave_push_parse' function's body is more than 2000 lines long. You should consider refactoring the code. | ||
oct-parse.yy (3346) |
V668 | There is no sense in testing the 'fcn' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
oct-parse.yy (3866) |
V522 | There might be dereferencing of a potential null pointer 'fcn_def'. | ||
oct-parse.yy (4093) |
V522 | There might be dereferencing of a potential null pointer 'al'. | ||
profiler.cc (244) |
V783 | Dereferencing of the invalid iterator 'pos' might take place. | ||
pt-arg-list.cc (138) |
V522 | There might be dereferencing of a potential null pointer 'id'. | ||
pt-arg-list.cc (145) |
V522 | There might be dereferencing of a potential null pointer 'idx_expr'. | ||
pt-assign.cc (38) |
V730 | Not all members of a class are initialized inside the constructor. Consider inspecting: m_ans_assign. | ||
pt-bp.cc (449) |
V547 | Expression 'm_action == list' is always true. | ||
pt-bp.cc (480) |
V547 | Expression 'm_action == list' is always true. | ||
pt-eval.cc (193) |
V773 | The function was exited without releasing the 'lxr' pointer. A memory leak is possible. | ||
pt-eval.cc (237) |
V522 | There might be dereferencing of a potential null pointer 'id'. | ||
pt-eval.cc (1973) |
V522 | There might be dereferencing of a potential null pointer 'id'. | ||
pt-eval.cc (2764) |
V522 | There might be dereferencing of a potential null pointer 'expr'. | ||
pt-eval.cc (2791) |
V522 | There might be dereferencing of a potential null pointer 'id'. | ||
pt-eval.cc (3467) |
V522 | There might be dereferencing of a potential null pointer. | ||
pt-eval.cc (3529) |
V522 | There might be dereferencing of a potential null pointer 'fcn'. | ||
pt-eval.cc (3745) |
V522 | There might be dereferencing of a potential null pointer 'code'. | ||
__betainc__.cc (109) |
V550 | An odd precise comparison: Dj == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
__betainc__.cc (112) |
V550 | An odd precise comparison: Cj == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
__betainc__.cc (180) |
V550 | An odd precise comparison: Dj == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
__betainc__.cc (183) |
V550 | An odd precise comparison: Cj == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
__ichol__.cc (56) |
V550 | An odd precise comparison: pivot.imag() != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
__ilu__.cc (661) |
V783 | Dereferencing of the invalid iterator 'it' might take place. | ||
__ilu__.cc (670) |
V783 | Dereferencing of the invalid iterator '++ it' might take place. | ||
__ilu__.cc (746) |
V550 | An odd precise comparison: udiag != 1. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
__magick_read__.cc (417) |
V636 | The expression was implicitly cast from 'unsigned long long' type to 'double' type. Consider utilizing an explicit type cast to avoid the loss of a fractional part. An example: double A = (double)(X) / Y;. | ||
__magick_read__.cc (772) |
V522 | There might be dereferencing of a potential null pointer 'static_locale'. A constructor of the string class expects a valid pointer. | ||
__qp__.cc (257) |
V547 | Expression 'pR == 0' is always true. | ||
__qp__.cc (261) |
V547 | Expression 'pR == 0' is always true. | ||
besselj.cc (102) |
V550 | An odd precise comparison: opt_val != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
besselj.cc (102) |
V550 | An odd precise comparison: opt_val != 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
besselj.cc (104) |
V550 | An odd precise comparison: opt_val == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
besselj.cc (133) |
V614 | Potentially uninitialized variable 'ierr' used. | ||
besselj.cc (223) |
V614 | Potentially uninitialized variable 'ierr' used. | ||
call-stack.cc (708) |
V524 | It is odd that the body of 'regexp_symbol_info' function is fully equivalent to the body of 'glob_symbol_info' function. | ||
DASPK-opts.h (87) |
V525 | The code contains the collection of similar blocks. Check items '5.0', '6.0', '5.0', '0.0' in lines 87, 88, 89, 90. | ||
DAERTFunc.h (86) |
V703 | It is odd that the 'reset' field in derived class 'DAERTFunc' overwrites field in base class 'DAEFunc'. Check lines: DAERTFunc.h:86, DAEFunc.h:101. | ||
oct-binmap.h (325) |
V560 | A part of conditional expression is always true: jy_lt_max. | ||
data.cc (1138) |
V550 | An odd precise comparison: cs != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
data.cc (1146) |
V550 | An odd precise comparison: cs != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
data.cc (7152) |
V550 | An odd precise comparison: r.inc() == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
defaults.cc (102) |
V560 | A part of conditional expression is always true: op == oep. | ||
defun.cc (196) |
V522 | There might be dereferencing of a potential null pointer 'dld'. | ||
defun.cc (202) |
V522 | There might be dereferencing of a potential null pointer 'mex'. | ||
display.cc (70) |
V668 | There is no sense in testing the 'instance' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
dlmread.cc (481) |
V550 | An odd precise comparison: y != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dot.cc (48) |
V656 | Variables 'z(i)', 'tmp_m' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'x(i)' expression. Check lines: 47, 48. | ||
dot.cc (53) |
V656 | Variables 'z(i)', 'tmp_n' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'x(i)' expression. Check lines: 52, 53. | ||
dot.cc (300) |
V560 | A part of conditional expression is always true: match. | ||
dot.cc (286) |
V525 | The code contains the collection of similar blocks. Check items 'dimx', 'dimx', 'dimy' in lines 286, 287, 288. | ||
dynamic-ld.cc (250) |
V519 | The 'retval' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 204, 250. | ||
error.cc (460) |
V764 | Possible incorrect order of arguments passed to 'vmessage_with_id' function: 'name' and 'id'. | ||
fcn-info.cc (414) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 379, 414. | ||
fcn-info.cc (631) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 594, 631. | ||
find.cc (401) |
V550 | An odd precise comparison: val != octave::math::fix(val). It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
text-engine.h (66) |
V690 | Copy constructor is declared as private in the 'text_element_string' class, but the default '=' operator will still be generated by compiler. It is dangerous to use such a class. | ||
ft-text-renderer.cc (153) |
V668 | There is no sense in testing the 'instance' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
ft-text-renderer.cc (788) |
V560 | A part of conditional expression is always false: x0 + c < 0. | ||
ft-text-renderer.cc (1260) |
V550 | An odd precise comparison: rotation == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ft-text-renderer.cc (1262) |
V550 | An odd precise comparison: rotation == 90.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ft-text-renderer.cc (1264) |
V550 | An odd precise comparison: rotation == 180.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ft-text-renderer.cc (1266) |
V550 | An odd precise comparison: rotation == 270.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
ft-text-renderer.cc (376) |
V730 | Not all members of a class are initialized inside the constructor. Consider inspecting: line_xoffset. | ||
gcd.cc (48) |
V550 | An odd precise comparison: bb != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
gcd.cc (131) |
V550 | An odd precise comparison: bb != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
getgrent.cc (96) |
V550 | An odd precise comparison: octave::math::x_nint(dval) != dval. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
getpwent.cc (102) |
V550 | An odd precise comparison: octave::math::x_nint(dval) != dval. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
gl-render.cc (2368) |
V1020 | The function exited without calling the 'm_glfcns.glEnd' function. Check lines: 2368, 2286. | ||
gl-render.cc (2368) |
V1020 | The function exited without calling the 'm_glfcns.glEnd' function. Check lines: 2368, 2312. | ||
gl-render.cc (2699) |
V550 | An odd precise comparison: props.get_edgealpha_double() == 1. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
gl-render.cc (3360) |
V550 | An odd precise comparison: props.get_edgealpha_double() == 1. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
gl-render.cc (3566) |
V1020 | The function exited without calling the 'm_glfcns.glEnd' function. Check lines: 3566, 3426. | ||
gl-render.cc (3565) |
V1020 | The function exited without calling the 'm_glfcns.glEnd' function. Check lines: 3565, 3426. | ||
gl-render.cc (3704) |
V550 | An odd precise comparison: rotation != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
gl-render.cc (3704) |
V550 | An odd precise comparison: rotation != 90.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
gl-render.cc (3705) |
V550 | An odd precise comparison: rotation != 180.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
gl-render.cc (3705) |
V550 | An odd precise comparison: rotation != 270.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
gl-render.cc (4616) |
V1034 | Do not use real type variables as loop counters. | ||
gl-render.cc (4638) |
V1034 | Do not use real type variables as loop counters. | ||
gl2ps-print.cc (825) |
V526 | The 'compare' function returns 0 if corresponding strings are equal. Consider examining the condition for mistakes. | ||
gl2ps-print.cc (828) |
V526 | The 'compare' function returns 0 if corresponding strings are equal. Consider examining the condition for mistakes. | ||
gl2ps-print.cc (831) |
V526 | The 'compare' function returns 0 if corresponding strings are equal. Consider examining the condition for mistakes. | ||
graphics.cc (1445) |
V550 | An odd precise comparison: new_dval != dval. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
graphics.cc (1554) |
V547 | Expression 'finite_constraint == NOT_INF' is always true. | ||
graphics.cc (1600) |
V550 | An odd precise comparison: data.scalar_value() == v.scalar_value(). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (1600) |
V550 | An odd precise comparison: d1[i] != d2[i]. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
graphics.cc (1602) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (1602) |
V550 | An odd precise comparison: d1[i] != d2[i]. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
graphics.cc (2107) |
V550 | An odd precise comparison: cf.double_value() == __myhandle__. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (2727) |
V550 | An odd precise comparison: h.value() == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (3248) |
V550 | An odd precise comparison: hp == __myhandle__. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (3259) |
V550 | An odd precise comparison: old_parent_go.get_handle() != hp. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
graphics.cc (3394) |
V550 | An odd precise comparison: cbo.double_value() == __myhandle__. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (3408) |
V550 | An odd precise comparison: co.double_value() == __myhandle__. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics-props.cc (123) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 121, 123. | ||
graphics-props.cc (972) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 970, 972. | ||
graphics-props.cc (974) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 972, 974. | ||
graphics-props.cc (976) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 974, 976. | ||
graphics-props.cc (978) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 976, 978. | ||
graphics-props.cc (980) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 978, 980. | ||
graphics-props.cc (982) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 980, 982. | ||
graphics-props.cc (984) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 982, 984. | ||
graphics-props.cc (986) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 984, 986. | ||
graphics-props.cc (988) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 986, 988. | ||
graphics-props.cc (990) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 988, 990. | ||
graphics-props.cc (992) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 990, 992. | ||
graphics-props.cc (994) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 992, 994. | ||
graphics-props.cc (996) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 994, 996. | ||
graphics-props.cc (998) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 996, 998. | ||
graphics-props.cc (1000) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 998, 1000. | ||
graphics-props.cc (1002) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 1000, 1002. | ||
graphics-props.cc (1004) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 1002, 1004. | ||
graphics-props.cc (1006) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 1004, 1006. | ||
graphics-props.cc (1008) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 1006, 1008. | ||
graphics-props.cc (1010) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 1008, 1010. | ||
graphics-props.cc (1012) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 1010, 1012. | ||
graphics-props.cc (2173) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 2171, 2173. | ||
graphics-props.cc (2175) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 2173, 2175. | ||
graphics-props.cc (2177) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 2175, 2177. | ||
graphics-props.cc (2179) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 2177, 2179. | ||
graphics-props.cc (2181) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 2179, 2181. | ||
graphics-props.cc (3142) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 3140, 3142. | ||
graphics-props.cc (3144) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 3142, 3144. | ||
graphics-props.cc (3146) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 3144, 3146. | ||
graphics-props.cc (3148) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 3146, 3148. | ||
graphics-props.cc (3150) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 3148, 3150. | ||
graphics-props.cc (3584) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 3582, 3584. | ||
graphics-props.cc (3586) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 3584, 3586. | ||
graphics-props.cc (3588) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 3586, 3588. | ||
graphics-props.cc (3590) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 3588, 3590. | ||
graphics-props.cc (3592) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 3590, 3592. | ||
graphics-props.cc (3594) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 3592, 3594. | ||
graphics-props.cc (3596) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 3594, 3596. | ||
graphics-props.cc (3598) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 3596, 3598. | ||
graphics-props.cc (3600) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 3598, 3600. | ||
graphics-props.cc (3602) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 3600, 3602. | ||
graphics-props.cc (3604) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 3602, 3604. | ||
graphics-props.cc (4022) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4020, 4022. | ||
graphics-props.cc (4024) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4022, 4024. | ||
graphics-props.cc (4026) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4024, 4026. | ||
graphics-props.cc (4028) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4026, 4028. | ||
graphics-props.cc (4030) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4028, 4030. | ||
graphics-props.cc (4032) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4030, 4032. | ||
graphics-props.cc (4034) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4032, 4034. | ||
graphics-props.cc (4036) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4034, 4036. | ||
graphics-props.cc (4038) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4036, 4038. | ||
graphics-props.cc (4677) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4675, 4677. | ||
graphics-props.cc (4679) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4677, 4679. | ||
graphics-props.cc (4681) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4679, 4681. | ||
graphics-props.cc (4683) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4681, 4683. | ||
graphics-props.cc (4685) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4683, 4685. | ||
graphics-props.cc (4687) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4685, 4687. | ||
graphics-props.cc (4689) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4687, 4689. | ||
graphics-props.cc (4691) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4689, 4691. | ||
graphics-props.cc (4693) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 4691, 4693. | ||
graphics-props.cc (5333) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5331, 5333. | ||
graphics-props.cc (5335) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5333, 5335. | ||
graphics-props.cc (5337) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5335, 5337. | ||
graphics-props.cc (5339) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5337, 5339. | ||
graphics-props.cc (5341) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5339, 5341. | ||
graphics-props.cc (5343) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5341, 5343. | ||
graphics-props.cc (5345) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5343, 5345. | ||
graphics-props.cc (5347) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5345, 5347. | ||
graphics-props.cc (5349) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5347, 5349. | ||
graphics-props.cc (5824) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5822, 5824. | ||
graphics-props.cc (5826) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5824, 5826. | ||
graphics-props.cc (5828) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5826, 5828. | ||
graphics-props.cc (5830) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5828, 5830. | ||
graphics-props.cc (5832) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5830, 5832. | ||
graphics-props.cc (5834) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5832, 5834. | ||
graphics-props.cc (5836) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5834, 5836. | ||
graphics-props.cc (5838) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5836, 5838. | ||
graphics-props.cc (5840) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 5838, 5840. | ||
graphics-props.cc (6110) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 6108, 6110. | ||
graphics-props.cc (6632) |
V581 | The conditional expressions of the 'if' statements situated alongside each other are identical. Check lines: 6630, 6632. | ||
graphics.cc (5773) |
V550 | An odd precise comparison: el == 90. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (5773) |
V550 | An odd precise comparison: el == - 90. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (5798) |
V550 | An odd precise comparison: el == 90. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (5798) |
V550 | An odd precise comparison: el == - 90. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (5993) |
V550 | An odd precise comparison: xPlane == x_min. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (6021) |
V550 | An odd precise comparison: yPlane == y_min. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (6049) |
V550 | An odd precise comparison: zPlane == z_min. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (6760) |
V525 | The code contains the collection of similar blocks. Check items 'val', 'val', 'val', 'tval' in lines 6760, 6761, 6762, 6763. | ||
graphics.cc (6837) |
V547 | Expression 'i == 3' is always true. | ||
graphics.cc (6860) |
V550 | An odd precise comparison: dpr != 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
graphics.cc (6869) |
V550 | An odd precise comparison: text_rotation == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (6869) |
V550 | An odd precise comparison: text_rotation == 180.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (6871) |
V550 | An odd precise comparison: text_rotation == 90.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (6871) |
V550 | An odd precise comparison: text_rotation == 270.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (7232) |
V550 | An odd precise comparison: x == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (7517) |
V550 | An odd precise comparison: max_val == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (7551) |
V550 | An odd precise comparison: min_val == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (7551) |
V550 | An odd precise comparison: max_val == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (8294) |
V550 | An odd precise comparison: min_val == max_val. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (8322) |
V550 | An odd precise comparison: min_val == max_val. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (8493) |
V550 | An odd precise comparison: min_val == max_val. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (8521) |
V550 | An odd precise comparison: min_val == max_val. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (8959) |
V550 | An odd precise comparison: ca.double_value() == __myhandle__. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (9519) |
V656 | Variables 'xd', 'yd' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'idx.dims()' expression. Check lines: 9518, 9519. | ||
graphics.cc (11224) |
V668 | There is no sense in testing the 'instance' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
graphics.cc (12562) |
V550 | An odd precise comparison: octave::math::x_nint(val) == val. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (13164) |
V1020 | The function exited without calling the 'gh_manager::unlock' function. Check lines: 13164, 13085. | ||
graphics.cc (13164) |
V1020 | The function exited without calling the 'gh_manager::unlock' function. Check lines: 13164, 13109. | ||
graphics.cc (13587) |
V550 | An odd precise comparison: h == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
graphics.cc (11417) |
V730 | Not all members of a class are initialized inside the constructor. Consider inspecting: notify_toolkit. | ||
gsvd.cc (184) |
V656 | Variables 'retval(0)', 'retval(1)' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'octave::float_identity_matrix(nc, nc)' expression. Check lines: 183, 184. | ||
gsvd.cc (197) |
V656 | Variables 'retval(0)', 'retval(1)' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'octave::identity_matrix(nc, nc)' expression. Check lines: 196, 197. | ||
inv.cc (192) |
V550 | An odd precise comparison: xrcond + 1.0F == 1.0F. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
inv.cc (197) |
V550 | An odd precise comparison: xrcond + 1.0 == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
inv.cc (200) |
V614 | Potentially uninitialized variable 'info' used. | ||
load-save.cc (659) |
V1024 | The 'is' stream is checked for EOF before reading from it, but is not checked after reading. Potential use of invalid data. | ||
load-save.cc (1049) |
V636 | The 'val.byte_size() / 1024' expression was implicitly cast from 'size_t' type to 'double' type. Consider utilizing an explicit type cast to avoid the loss of a fractional part. An example: double A = (double)(X) / Y;. | ||
load-save.cc (1124) |
V601 | The 'true' value is implicitly cast to the integer type. Inspect the eighth argument. | ||
load-save.cc (1510) |
V560 | A part of conditional expression is always false: append. | ||
ls-hdf5.cc (1011) |
V547 | Expression 'retval >= 0' is always true. | ||
ls-mat-ascii.cc (273) |
V560 | A part of conditional expression is always false: nr < 1. | ||
ls-mat-ascii.cc (273) |
V560 | A part of conditional expression is always false: nc < 1. | ||
ls-mat5.cc (501) |
V728 | An excessive check can be simplified. The '(A && !B) || (!A && B)' expression is equivalent to the 'bool(A) != bool(B)' expression. | ||
ls-mat5.cc (1625) |
V525 | The code contains the collection of similar blocks. Check items '4', '1', '2', '4', '1', '2', '4' in lines 1625, 1626, 1627, 1628, 1629, 1630, 1631. | ||
ls-mat5.cc (1710) |
V525 | The code contains the collection of similar blocks. Check items '4', '1', '2', '4', '1', '2', '4' in lines 1710, 1711, 1712, 1713, 1714, 1715, 1716. | ||
ls-mat5.cc (2013) |
V560 | A part of conditional expression is always true: nel > 0. | ||
ls-mat5.cc (2013) |
V560 | A part of conditional expression is always true. | ||
ls-mat5.cc (2013) |
V560 | A part of conditional expression is always false. | ||
ls-mat5.cc (2183) |
V547 | Expression '6 > max_namelen' is always false. | ||
ls-oct-text.cc (403) |
V560 | A part of conditional expression is always true: !fail. | ||
lu.cc (171) |
V656 | Variables 'thres(0)', 'thres(1)' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'tmp(0)' expression. Check lines: 170, 171. | ||
mappers.cc (234) |
V524 | It is odd that the body of 'Farg' function is fully equivalent to the body of 'Fangle' function. | ||
mex.cc (289) |
V522 | There might be dereferencing of a potential null pointer 'dims'. Check lines: 289, 283. | ||
mex.cc (432) |
V601 | The bool type is implicitly cast to the double type. | ||
mex.cc (436) |
V523 | The 'then' statement is equivalent to the 'else' statement. | ||
mex.cc (681) |
V522 | There might be dereferencing of a potential null pointer 'dims'. Check lines: 681, 677. | ||
mex.cc (708) |
V522 | There might be dereferencing of a potential null pointer 'dims'. Check lines: 708, 705. | ||
mex.cc (723) |
V522 | There might be dereferencing of a potential null pointer 'dims'. Check lines: 723, 721. | ||
mex.cc (733) |
V522 | There might be dereferencing of a potential null pointer 'dims'. Check lines: 733, 730. | ||
mex.cc (893) |
V575 | The potential null pointer is passed into 'strcpy' function. Inspect the first argument. Check lines: 893, 892. | ||
mex.cc (1225) |
V601 | The bool type is implicitly cast to the double type. | ||
mex.cc (1708) |
V522 | There might be dereferencing of a potential null pointer 'fields'. Check lines: 1708, 1701. | ||
mex.cc (1819) |
V522 | There might be dereferencing of a potential null pointer 'new_fields'. Check lines: 1819, 1812. | ||
mex.cc (1835) |
V522 | There might be dereferencing of a potential null pointer 'new_data'. Check lines: 1835, 1815. | ||
mex.cc (1955) |
V522 | There might be dereferencing of a potential null pointer 'data'. Check lines: 1955, 1947. | ||
mex.cc (3173) |
V506 | Pointer to local variable 'context' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
mex.cc (3411) |
V575 | The potential null pointer is passed into 'strlen' function. Inspect the first argument. | ||
mex.cc (3459) |
V575 | The potential null pointer is passed into 'strlen' function. Inspect the first argument. | ||
mex.cc (3658) |
V522 | There might be dereferencing of a potential null pointer 'fname'. | ||
mex.cc (3711) |
V522 | There might be dereferencing of a potential null pointer 'fname'. | ||
oct-hdf5-types.cc (43) |
V560 | A part of conditional expression is always false: !ok. | ||
oct-hdf5-types.cc (50) |
V560 | A part of conditional expression is always false: !ok. | ||
oct-map.cc (73) |
V659 | Declarations of functions with 'octave_fields::getfield' name differ in the 'const' keyword only, but the bodies of these functions have different composition. This is suspicious and can possibly be an error. Check lines: 66, 73. | ||
oct-map.cc (254) |
V659 | Declarations of functions with 'octave_scalar_map::contents' name differ in the 'const' keyword only, but the bodies of these functions have different composition. This is suspicious and can possibly be an error. Check lines: 249, 254. | ||
oct-map.cc (352) |
V659 | Declarations of functions with 'octave_map::contents' name differ in the 'const' keyword only, but the bodies of these functions have different composition. This is suspicious and can possibly be an error. Check lines: 347, 352. | ||
oct-procbuf.cc (147) |
V631 | Consider inspecting the 'execl' function call. Defining an absolute path to the file or directory is considered a poor style. | ||
oct-stream.cc (107) |
V550 | An odd precise comparison: ival == dval. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-stream.cc (166) |
V550 | An odd precise comparison: dnr == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-stream.cc (572) |
V669 | The 'width' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
oct-stream.cc (893) |
V764 | Possible incorrect order of arguments passed to 'process_conversion' function: 'type' and 'modifier'. | ||
oct-stream.cc (1272) |
V768 | The variable 'flags' is of enum type. It is odd that it is used as a variable of a Boolean-type. | ||
oct-stream.cc (2336) |
V669 | The 'width', 'prec', 'bitwidth' arguments are non-constant references. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
oct-stream.cc (2485) |
V550 | An odd precise comparison: val.imag() == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-stream.cc (2495) |
V560 | A part of conditional expression is always true: !progress. | ||
oct-stream.cc (2646) |
V765 | A compound assignment expression 'size += size + 1' is suspicious. Consider inspecting it for a possible error. | ||
oct-stream.cc (2789) |
V547 | Expression 'width_left' is always true. | ||
oct-stream.cc (2838) |
V547 | Expression 'width_left' is always true. | ||
oct-stream.cc (2846) |
V547 | Expression 'width_left' is always true. | ||
oct-stream.cc (3249) |
V550 | An odd precise comparison: v.imag() == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-stream.cc (3261) |
V550 | An odd precise comparison: v.imag() == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-stream.cc (3480) |
V522 | There might be dereferencing of a potential null pointer 'elem'. | ||
oct-stream.cc (5447) |
V550 | An odd precise comparison: math::x_nint(dval) != dval. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
oct-stream.cc (5474) |
V550 | An odd precise comparison: math::x_nint(dval) == dval. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-stream.cc (5523) |
V550 | An odd precise comparison: math::x_nint(dval) == dval. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-stream.cc (5618) |
V550 | An odd precise comparison: dval == math::fix(dval). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-stream.cc (5645) |
V550 | An odd precise comparison: dval == math::fix(dval). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-stream.cc (2510) |
V730 | Not all members of a class are initialized inside the constructor. Consider inspecting: delim_len. | ||
oct-tex-lexer.ll (108) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 108, 108. | ||
oct-tex-lexer.ll (118) |
V519 | The 'yyg->yy_c_buf_p' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 118, 118. | ||
oct-tex-lexer.cc (2216) |
V1028 | Possible overflow. Consider casting operands of the 'b->yy_buf_size + 2' operator to the 'yy_size_t' type, not the result. | ||
oct-tex-lexer.cc (2435) |
V779 | Unreachable code detected. It is possible that an error is present. | ||
oct-tex-lexer.cc (2503) |
V1004 | The 'yyg->yy_buffer_stack' pointer was used unsafely after it was verified against nullptr. Check lines: 2492, 2503. | ||
oct-tex-lexer.cc (2542) |
V1028 | Possible overflow. Consider casting operands of the 'b->yy_buf_size + 2' operator to the 'yy_size_t' type, not the result. | ||
oct-tex-lexer.cc (2656) |
V1004 | The 'yyg->yy_buffer_stack' pointer was used unsafely after it was verified against nullptr. Check lines: 2645, 2656. | ||
oct-tex-lexer.cc (2674) |
V1004 | The 'yyg->yy_buffer_stack' pointer was used unsafely after it was verified against nullptr. Check lines: 2670, 2674. | ||
oct-tex-lexer.cc (2795) |
V1028 | Possible overflow. Consider casting operands of the '_yybytes_len + 2' operator to the 'yy_size_t' type, not the result. | ||
oct-tex-lexer.cc (2867) |
V1004 | The 'yyg->yy_buffer_stack' pointer was used unsafely after it was verified against nullptr. Check lines: 2864, 2867. | ||
oct-tex-lexer.cc (2880) |
V1004 | The 'yyg->yy_buffer_stack' pointer was used unsafely after it was verified against nullptr. Check lines: 2877, 2880. | ||
oct-tex-lexer.cc (2942) |
V1004 | The 'yyg->yy_buffer_stack' pointer was used unsafely after it was verified against nullptr. Check lines: 2939, 2942. | ||
oct-tex-lexer.cc (2957) |
V1004 | The 'yyg->yy_buffer_stack' pointer was used unsafely after it was verified against nullptr. Check lines: 2954, 2957. | ||
oct-tex-lexer.cc (386) |
V1003 | The macro 'YY_STATE_EOF' is a dangerous expression. The parameter 'state' must be surrounded by parentheses. | ||
oct-tex-parser.cc (1638) |
V557 | Array underrun is possible. The value of 'yyn - 20' index could reach -20. | ||
oct-tex-parser.cc (1642) |
V557 | Array underrun is possible. The value of 'yyn - 20' index could reach -20. | ||
pager.cc (390) |
V728 | An excessive check can be simplified. The '||' operator is surrounded by opposite expressions '!m_page_screen_output' and 'm_page_screen_output'. | ||
pager.cc (429) |
V668 | There is no sense in testing the 'm_external_pager' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
pr-output.cc (415) |
V560 | A part of conditional expression is always false: inf_or_nan. | ||
pr-output.cc (517) |
V560 | A part of conditional expression is always false: fw < 5. | ||
pr-output.cc (690) |
V560 | A part of conditional expression is always false: r_fw < 5. | ||
pr-output.cc (758) |
V560 | A part of conditional expression is always false: inf_or_nan. | ||
pr-output.cc (909) |
V560 | A part of conditional expression is always false: r_fw < 5. | ||
pr-output.cc (1256) |
V550 | An odd precise comparison: max_abs == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
pr-output.cc (1258) |
V550 | An odd precise comparison: min_abs == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
pr-output.cc (1423) |
V550 | An odd precise comparison: scale != 1. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
pr-output.cc (1520) |
V550 | An odd precise comparison: scale != 1. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
pr-output.cc (1840) |
V560 | A part of conditional expression is always true: j < lim. | ||
pr-output.cc (1956) |
V560 | A part of conditional expression is always true: j < lim. | ||
pr-output.cc (2094) |
V547 | Expression 'i < m' is always true. | ||
pr-output.cc (2250) |
V560 | A part of conditional expression is always true: j < lim. | ||
pr-output.cc (2420) |
V550 | An odd precise comparison: increment != 1. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
pr-output.cc (2428) |
V550 | An odd precise comparison: increment != 1. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
pr-output.cc (2694) |
V547 | Expression 'i < m' is always true. | ||
qz.cc (217) |
V550 | An odd precise comparison: safmin == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
regexp.cc (518) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
sparse-xdiv.cc (377) |
V550 | An odd precise comparison: a == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
sparse-xpow.cc (49) |
V550 | An odd precise comparison: octave::math::x_nint(x) == x. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
sparse-xpow.cc (485) |
V550 | An odd precise comparison: b == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
sparse-xpow.cc (690) |
V550 | An odd precise comparison: b == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
strfns.cc (903) |
V519 | The 'utf8_str' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 899, 903. | ||
strfns.cc (955) |
V519 | The 'native_bytes' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 951, 955. | ||
syminfo.cc (531) |
V614 | Potentially uninitialized variable 'param.balance' used. | ||
syminfo.cc (446) |
V1026 | The 'idx' variable is incremented in the loop. Undefined behavior will occur in case of signed integer overflow. | ||
syminfo.cc (555) |
V1026 | The 'idx' variable is incremented in the loop. Undefined behavior will occur in case of signed integer overflow. | ||
sysdep.cc (233) |
V550 | An odd precise comparison: tmp(0).double_value() == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
utils.cc (188) |
V668 | There is no sense in testing the 's2' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
utils.cc (1103) |
V656 | Variables 'dim(0)', 'dim(1)' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'v(0)' expression. Check lines: 1102, 1103. | ||
xpow.cc (133) |
V550 | An odd precise comparison: std::imag(elt) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
xpow.cc (184) |
V550 | An odd precise comparison: std::imag(elt) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
xpow.cc (397) |
V550 | An odd precise comparison: std::imag(elt) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
xpow.cc (445) |
V550 | An odd precise comparison: std::imag(elt) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
xpow.cc (1532) |
V550 | An odd precise comparison: std::imag(elt) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
xpow.cc (1584) |
V550 | An odd precise comparison: std::imag(elt) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
xpow.cc (1787) |
V550 | An odd precise comparison: std::imag(elt) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
xpow.cc (1835) |
V550 | An odd precise comparison: std::imag(elt) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
zfstream.cc (282) |
V1004 | The 'buffer' pointer was used unsafely after it was verified against nullptr. Check lines: 271, 282. | ||
Array-d.cc (138) |
V547 | Expression 'mode == ASCENDING' is always true. | ||
Array-f.cc (138) |
V547 | Expression 'mode == ASCENDING' is always true. | ||
boolSparse.cc (141) |
V1008 | Consider inspecting the 'for' operator. No more than one iteration of the loop will be performed. | ||
boolSparse.cc (141) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
CDiagMatrix.cc (250) |
V728 | An excessive check can be simplified. The '||' operator is surrounded by opposite expressions 'r <= c' and 'r > c'. | ||
CDiagMatrix.cc (262) |
V1004 | The 's' pointer was used unsafely after it was verified against nullptr. Check lines: 259, 262. | ||
CDiagMatrix.cc (269) |
V591 | Non-void function should return a value. | ||
CDiagMatrix.cc (280) |
V728 | An excessive check can be simplified. The '||' operator is surrounded by opposite expressions 'r >= c' and 'r < c'. | ||
CDiagMatrix.cc (292) |
V1004 | The 's' pointer was used unsafely after it was verified against nullptr. Check lines: 289, 292. | ||
CDiagMatrix.cc (299) |
V591 | Non-void function should return a value. | ||
CDiagMatrix.cc (345) |
V550 | An odd precise comparison: val == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CDiagMatrix.cc (490) |
V550 | An odd precise comparison: amx == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CMatrix.cc (960) |
V550 | An odd precise comparison: rcon == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CMatrix.cc (996) |
V550 | An odd precise comparison: tol == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CMatrix.cc (1081) |
V656 | Variables 'dv', 'retval' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'rows(), cols()' expression. Check lines: 1079, 1081. | ||
CMatrix.cc (1095) |
V656 | Variables 'dv', 'retval' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'rows(), cols()' expression. Check lines: 1093, 1095. | ||
CMatrix.cc (1582) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CMatrix.cc (1680) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CMatrix.cc (1772) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CMatrix.cc (1867) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CMatrix.cc (2408) |
V550 | An odd precise comparison: s.elem(0) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CMatrix.cc (2584) |
V550 | An odd precise comparison: s.elem(0) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CMatrix.cc (3215) |
V525 | The code contains the collection of similar blocks. Check items 'cc', 'cc', 'cs' in lines 3215, 3216, 3217. | ||
CNDArray.cc (326) |
V550 | An odd precise comparison: octave::math::x_nint(r_val) != r_val. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CNDArray.cc (327) |
V550 | An odd precise comparison: octave::math::x_nint(i_val) != i_val. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (254) |
V550 | An odd precise comparison: abs_max != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (265) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (330) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (411) |
V550 | An odd precise comparison: abs_min != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (422) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (487) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (832) |
V550 | An odd precise comparison: pivot == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (835) |
V550 | An odd precise comparison: v != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (856) |
V550 | An odd precise comparison: pivot == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (859) |
V550 | An odd precise comparison: pivot != 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (920) |
V550 | An odd precise comparison: pivot == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (934) |
V550 | An odd precise comparison: pivot == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (939) |
V550 | An odd precise comparison: work[j] != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (942) |
V550 | An odd precise comparison: pivot != 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (954) |
V550 | An odd precise comparison: work[j] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (1565) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (1603) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (1641) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (1676) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (1715) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (1804) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (1828) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (1840) |
V550 | An odd precise comparison: work[rperm[i]] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (1864) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (1901) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (1924) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (1936) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (1958) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (1997) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (2076) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2114) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2152) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2187) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2226) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (2315) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2339) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2351) |
V550 | An odd precise comparison: work[rperm[i]] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2375) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2412) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2435) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2447) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2469) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2508) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (2586) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2633) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2685) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2719) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2757) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (2841) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2876) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2888) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2910) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2962) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2984) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (2996) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (3019) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (3058) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (3136) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (3183) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (3236) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (3271) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (3310) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (3393) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (3428) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (3440) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (3462) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (3514) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (3536) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (3548) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (3571) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (3610) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Array.h (454) |
V512 | Instantiation of Array < F77_INT >: A call of the 'compute_index' function will lead to overflow of the buffer 'ra_idx.data()'. | ||
CSparse.cc (3928) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (3940) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (3951) |
V547 | Expression 'typ != MatrixType::Tridiagonal_Hermitian' is always true. | ||
CSparse.cc (4271) |
V550 | An odd precise comparison: Bx[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (4283) |
V550 | An odd precise comparison: Bx[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (4295) |
V547 | Expression 'typ != MatrixType::Tridiagonal_Hermitian' is always true. | ||
CSparse.cc (4397) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (4530) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (4666) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (4720) |
V550 | An odd precise comparison: tmp != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (4832) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (4880) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (4892) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (5007) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (5137) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (5275) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (5331) |
V550 | An odd precise comparison: Bx[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (5343) |
V550 | An odd precise comparison: Bx[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (5445) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (5494) |
V550 | An odd precise comparison: Bx[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (5506) |
V550 | An odd precise comparison: Bx[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (5609) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (5688) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
CSparse.cc (5691) |
V550 | An odd precise comparison: spu == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (5706) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (5717) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (5718) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (5756) |
V550 | An odd precise comparison: rcond == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (5766) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (5731) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
CSparse.cc (5744) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
CSparse.cc (5940) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
CSparse.cc (5943) |
V550 | An odd precise comparison: spu == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (5958) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (5969) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (5970) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (5992) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (5993) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (6018) |
V550 | An odd precise comparison: rcond == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (6028) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (5983) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
CSparse.cc (6006) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
CSparse.cc (6166) |
V550 | An odd precise comparison: tmp != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (6243) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
CSparse.cc (6246) |
V550 | An odd precise comparison: spu == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (6261) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (6272) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (6273) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (6311) |
V550 | An odd precise comparison: rcond == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (6321) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (6286) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
CSparse.cc (6299) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
CSparse.cc (6474) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
CSparse.cc (6477) |
V550 | An odd precise comparison: spu == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (6492) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (6503) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (6504) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (6526) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (6527) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (6552) |
V550 | An odd precise comparison: rcond == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (6562) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (6517) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
CSparse.cc (6540) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
CSparse.cc (6676) |
V550 | An odd precise comparison: tmp != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (6701) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
CSparse.cc (7378) |
V550 | An odd precise comparison: octave::math::x_nint(r_val) != r_val. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (7379) |
V550 | An odd precise comparison: octave::math::x_nint(i_val) != i_val. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (7357) |
V656 | Variables 'max_val', 'min_val' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'std::real(data(0))' expression. Check lines: 7356, 7357. | ||
CSparse.cc (7397) |
V1008 | Consider inspecting the 'for' operator. No more than one iteration of the loop will be performed. | ||
CSparse.cc (7397) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
CSparse.cc (7403) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
CSparse.cc (7403) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
CSparse.cc (7425) |
V1008 | Consider inspecting the 'for' operator. No more than one iteration of the loop will be performed. | ||
CSparse.cc (7425) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(1.0) > Epsilon. | ||
CSparse.cc (7433) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(0.0) > Epsilon. | ||
CSparse.cc (7447) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(0.0) > Epsilon. | ||
CSparse.cc (7764) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (7774) |
V560 | A part of conditional expression is always true: jb_lt_max. | ||
CSparse.cc (7777) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (7789) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (7830) |
V550 | An odd precise comparison: octave::math::max(c, 0.) != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (7881) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (7891) |
V560 | A part of conditional expression is always true: jb_lt_max. | ||
CSparse.cc (7894) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
CSparse.cc (7906) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dDiagMatrix.cc (173) |
V728 | An excessive check can be simplified. The '||' operator is surrounded by opposite expressions 'r <= c' and 'r > c'. | ||
dDiagMatrix.cc (185) |
V1004 | The 's' pointer was used unsafely after it was verified against nullptr. Check lines: 182, 185. | ||
dDiagMatrix.cc (192) |
V591 | Non-void function should return a value. | ||
dDiagMatrix.cc (203) |
V728 | An excessive check can be simplified. The '||' operator is surrounded by opposite expressions 'r >= c' and 'r < c'. | ||
dDiagMatrix.cc (215) |
V1004 | The 's' pointer was used unsafely after it was verified against nullptr. Check lines: 212, 215. | ||
dDiagMatrix.cc (222) |
V591 | Non-void function should return a value. | ||
dDiagMatrix.cc (266) |
V550 | An odd precise comparison: val == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dDiagMatrix.cc (326) |
V550 | An odd precise comparison: amx == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dMatrix.cc (665) |
V550 | An odd precise comparison: rcon == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dMatrix.cc (695) |
V550 | An odd precise comparison: tol == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dMatrix.cc (1262) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dMatrix.cc (1359) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dMatrix.cc (1447) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dMatrix.cc (1536) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dMatrix.cc (2059) |
V550 | An odd precise comparison: s.elem(0) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dMatrix.cc (2225) |
V550 | An odd precise comparison: s.elem(0) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dNDArray.cc (353) |
V656 | Variables 'max_val', 'min_val' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'elem(0)' expression. Check lines: 352, 353. | ||
dRowVector.cc (279) |
V550 | An odd precise comparison: x1 == x2. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (247) |
V550 | An odd precise comparison: tmp_max != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (258) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (324) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (398) |
V550 | An odd precise comparison: tmp_min != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (409) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (475) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (775) |
V550 | An odd precise comparison: pivot == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (778) |
V550 | An odd precise comparison: v != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (799) |
V550 | An odd precise comparison: pivot == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (802) |
V550 | An odd precise comparison: pivot != 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (863) |
V550 | An odd precise comparison: pivot == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (877) |
V550 | An odd precise comparison: pivot == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (882) |
V550 | An odd precise comparison: work[j] != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (885) |
V550 | An odd precise comparison: pivot != 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (897) |
V550 | An odd precise comparison: work[j] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (1499) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (1537) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (1575) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (1610) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (1648) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (1737) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (1761) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (1773) |
V550 | An odd precise comparison: work[rperm[i]] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (1797) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (1834) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (1857) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (1869) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (1891) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (1930) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (2009) |
V550 | An odd precise comparison: cwork[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2048) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2086) |
V550 | An odd precise comparison: cwork[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2122) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2161) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (2250) |
V550 | An odd precise comparison: cwork[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2274) |
V550 | An odd precise comparison: cwork[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2286) |
V550 | An odd precise comparison: cwork[rperm[i]] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2311) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2348) |
V550 | An odd precise comparison: cwork[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2371) |
V550 | An odd precise comparison: cwork[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2383) |
V550 | An odd precise comparison: cwork[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2406) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2445) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (2524) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2571) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2623) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2659) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2698) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (2781) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2816) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2828) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2850) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2902) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2924) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2936) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2959) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (2998) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (3076) |
V550 | An odd precise comparison: cwork[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (3124) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (3177) |
V550 | An odd precise comparison: cwork[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (3213) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (3252) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (3335) |
V550 | An odd precise comparison: cwork[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (3370) |
V550 | An odd precise comparison: cwork[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (3382) |
V550 | An odd precise comparison: cwork[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (3405) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (3457) |
V550 | An odd precise comparison: cwork[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (3479) |
V550 | An odd precise comparison: cwork[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (3491) |
V550 | An odd precise comparison: cwork[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (3515) |
V550 | An odd precise comparison: work[k] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (3554) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (3861) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (3873) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (3884) |
V547 | Expression 'typ != MatrixType::Tridiagonal_Hermitian' is always true. | ||
dSparse.cc (4220) |
V550 | An odd precise comparison: Bx[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (4220) |
V550 | An odd precise comparison: Bz[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (4232) |
V550 | An odd precise comparison: Bx[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (4232) |
V550 | An odd precise comparison: Bz[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (4245) |
V547 | Expression 'typ != MatrixType::Tridiagonal_Hermitian' is always true. | ||
dSparse.cc (4347) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (4479) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (4615) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (4669) |
V550 | An odd precise comparison: tmp != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (4725) |
V614 | Uninitialized variable 'anorm' used. | ||
dSparse.cc (4780) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (4829) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (4841) |
V550 | An odd precise comparison: work[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (4956) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (5064) |
V614 | Uninitialized variable 'anorm' used. | ||
dSparse.cc (5119) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (5280) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (5359) |
V550 | An odd precise comparison: Bx[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (5359) |
V550 | An odd precise comparison: Bz[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (5371) |
V550 | An odd precise comparison: Bx[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (5371) |
V550 | An odd precise comparison: Bz[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (5418) |
V614 | Uninitialized variable 'anorm' used. | ||
dSparse.cc (5473) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (5537) |
V550 | An odd precise comparison: Bx[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (5537) |
V550 | An odd precise comparison: Bz[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (5549) |
V550 | An odd precise comparison: Bx[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (5549) |
V550 | An odd precise comparison: Bz[i] != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (5649) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (5729) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
dSparse.cc (5732) |
V550 | An odd precise comparison: spu == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (5747) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (5758) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (5759) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (5798) |
V550 | An odd precise comparison: rcond == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (5808) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (5772) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
dSparse.cc (5785) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
dSparse.cc (5954) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
dSparse.cc (5957) |
V550 | An odd precise comparison: spu == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (5972) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (5983) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (5984) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (6006) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (6007) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (6032) |
V550 | An odd precise comparison: rcond == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (6042) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (5997) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
dSparse.cc (6020) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
dSparse.cc (6150) |
V550 | An odd precise comparison: tmp != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (6227) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
dSparse.cc (6230) |
V550 | An odd precise comparison: spu == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (6245) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (6256) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (6257) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (6295) |
V550 | An odd precise comparison: rcond == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (6305) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (6270) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
dSparse.cc (6283) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
dSparse.cc (6472) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
dSparse.cc (6475) |
V550 | An odd precise comparison: spu == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (6490) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (6501) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (6502) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (6524) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (6525) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (6550) |
V550 | An odd precise comparison: rcond == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (6560) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (6515) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
dSparse.cc (6538) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
dSparse.cc (6681) |
V550 | An odd precise comparison: tmp != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7290) |
V550 | An odd precise comparison: val != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7290) |
V550 | An odd precise comparison: val != 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7317) |
V550 | An odd precise comparison: octave::math::x_nint(val) == val. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
dSparse.cc (7350) |
V550 | An odd precise comparison: octave::math::x_nint(val) != val. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7338) |
V656 | Variables 'max_val', 'min_val' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'data(0)' expression. Check lines: 7337, 7338. | ||
dSparse.cc (7402) |
V1008 | Consider inspecting the 'for' operator. No more than one iteration of the loop will be performed. | ||
dSparse.cc (7402) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
dSparse.cc (7408) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
dSparse.cc (7408) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
dSparse.cc (7420) |
V550 | An odd precise comparison: t != double (). It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7430) |
V1008 | Consider inspecting the 'for' operator. No more than one iteration of the loop will be performed. | ||
dSparse.cc (7430) |
V550 | An odd precise comparison: tmp[i] != double (). It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7430) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(1.0) > Epsilon. | ||
dSparse.cc (7438) |
V550 | An odd precise comparison: tmp[i] != double (). It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7438) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(0.0) > Epsilon. | ||
dSparse.cc (7452) |
V550 | An odd precise comparison: tmp[i] != double (). It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7452) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(0.0) > Epsilon. | ||
dSparse.cc (7645) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7658) |
V550 | An odd precise comparison: octave::math::min(d, m.data(i)) != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7671) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7722) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7732) |
V560 | A part of conditional expression is always true: jb_lt_max. | ||
dSparse.cc (7735) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7747) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7796) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7809) |
V550 | An odd precise comparison: octave::math::max(d, m.data(i)) != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7821) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7872) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7882) |
V560 | A part of conditional expression is always true: jb_lt_max. | ||
dSparse.cc (7885) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7897) |
V550 | An odd precise comparison: tmp != 0.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7928) |
V550 | An odd precise comparison: s != rhs_zero. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
dSparse.cc (7931) |
V550 | An odd precise comparison: s != lhs_zero. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
fCDiagMatrix.cc (254) |
V728 | An excessive check can be simplified. The '||' operator is surrounded by opposite expressions 'r <= c' and 'r > c'. | ||
fCDiagMatrix.cc (266) |
V1004 | The 's' pointer was used unsafely after it was verified against nullptr. Check lines: 263, 266. | ||
fCDiagMatrix.cc (273) |
V591 | Non-void function should return a value. | ||
fCDiagMatrix.cc (284) |
V728 | An excessive check can be simplified. The '||' operator is surrounded by opposite expressions 'r >= c' and 'r < c'. | ||
fCDiagMatrix.cc (296) |
V1004 | The 's' pointer was used unsafely after it was verified against nullptr. Check lines: 293, 296. | ||
fCDiagMatrix.cc (303) |
V591 | Non-void function should return a value. | ||
fCDiagMatrix.cc (349) |
V550 | An odd precise comparison: val == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fCDiagMatrix.cc (494) |
V550 | An odd precise comparison: amx == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fCMatrix.cc (963) |
V550 | An odd precise comparison: rcon == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fCMatrix.cc (999) |
V550 | An odd precise comparison: tol == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fCMatrix.cc (1084) |
V656 | Variables 'dv', 'retval' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'rows(), cols()' expression. Check lines: 1082, 1084. | ||
fCMatrix.cc (1098) |
V656 | Variables 'dv', 'retval' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'rows(), cols()' expression. Check lines: 1096, 1098. | ||
fCMatrix.cc (1584) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fCMatrix.cc (1686) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fCMatrix.cc (1782) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fCMatrix.cc (1877) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fCMatrix.cc (2434) |
V550 | An odd precise comparison: s.elem(0) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fCMatrix.cc (2613) |
V550 | An odd precise comparison: s.elem(0) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fCMatrix.cc (3244) |
V525 | The code contains the collection of similar blocks. Check items 'cc', 'cc', 'cs' in lines 3244, 3245, 3246. | ||
fCNDArray.cc (326) |
V550 | An odd precise comparison: octave::math::x_nint(r_val) != r_val. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
fCNDArray.cc (327) |
V550 | An odd precise comparison: octave::math::x_nint(i_val) != i_val. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
fDiagMatrix.cc (173) |
V728 | An excessive check can be simplified. The '||' operator is surrounded by opposite expressions 'r <= c' and 'r > c'. | ||
fDiagMatrix.cc (185) |
V1004 | The 's' pointer was used unsafely after it was verified against nullptr. Check lines: 182, 185. | ||
fDiagMatrix.cc (192) |
V591 | Non-void function should return a value. | ||
fDiagMatrix.cc (203) |
V728 | An excessive check can be simplified. The '||' operator is surrounded by opposite expressions 'r >= c' and 'r < c'. | ||
fDiagMatrix.cc (215) |
V1004 | The 's' pointer was used unsafely after it was verified against nullptr. Check lines: 212, 215. | ||
fDiagMatrix.cc (222) |
V591 | Non-void function should return a value. | ||
fDiagMatrix.cc (266) |
V550 | An odd precise comparison: val == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fDiagMatrix.cc (326) |
V550 | An odd precise comparison: amx == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fMatrix.cc (671) |
V550 | An odd precise comparison: rcon == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fMatrix.cc (701) |
V550 | An odd precise comparison: tol == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fMatrix.cc (1271) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fMatrix.cc (1374) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fMatrix.cc (1470) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fMatrix.cc (1556) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fMatrix.cc (2086) |
V550 | An odd precise comparison: s.elem(0) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fMatrix.cc (2250) |
V550 | An odd precise comparison: s.elem(0) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fNDArray.cc (310) |
V656 | Variables 'max_val', 'min_val' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'elem(0)' expression. Check lines: 309, 310. | ||
fRowVector.cc (279) |
V550 | An odd precise comparison: x1 == x2. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
idx-vector.cc (108) |
V591 | Non-void function should return a value. | ||
idx-vector.cc (155) |
V550 | An odd precise comparison: b != std::trunc(b). It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
idx-vector.cc (226) |
V669 | The 'conv_error' argument is a non-constant reference. The analyzer is unable to determine the position at which this argument is being modified. It is possible that the function contains an error. | ||
idx-vector.cc (243) |
V550 | An odd precise comparison: static_cast<double> (i) != x. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
idx-vector.cc (820) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (830) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (853) |
V522 | There might be dereferencing of a potential null pointer 'rj'. | ||
idx-vector.cc (868) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (869) |
V522 | There might be dereferencing of a potential null pointer 'rj'. | ||
idx-vector.cc (882) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (886) |
V522 | There might be dereferencing of a potential null pointer 'rj'. | ||
idx-vector.cc (910) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (910) |
V522 | There might be dereferencing of a potential null pointer 'rj'. | ||
idx-vector.cc (921) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (924) |
V522 | There might be dereferencing of a potential null pointer 'rj'. | ||
idx-vector.cc (934) |
V522 | There might be dereferencing of a potential null pointer 'rj'. | ||
idx-vector.cc (968) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (980) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (989) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (1018) |
V522 | There might be dereferencing of a potential null pointer 'dynamic_cast< idx_range_rep * > (rep)'. | ||
idx-vector.cc (1046) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (1063) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (1078) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (1085) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (1093) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (1118) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (1187) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (1208) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (1211) |
V781 | The value of the 'len' variable is checked after it was used. Perhaps there is a mistake in program logic. Check lines: 1211, 1217. | ||
idx-vector.cc (1239) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (1246) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (1253) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
idx-vector.cc (1260) |
V522 | There might be dereferencing of a potential null pointer 'r'. | ||
MatrixType.cc (121) |
V550 | An odd precise comparison: aij == aji. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
MatrixType.cc (244) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
MatrixType.cc (340) |
V550 | An odd precise comparison: sp_bandden != 1.. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
MatrixType.cc (511) |
V550 | An odd precise comparison: std::imag(d) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
MatrixType.cc (485) |
V586 | The 'delete' operator is called twice for deallocation of the same memory space. | ||
MatrixType.cc (653) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
MatrixType.cc (655) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
MatrixType.cc (662) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
MatrixType.cc (675) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
MatrixType.cc (677) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
MatrixType.cc (707) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
MatrixType.cc (709) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
MatrixType.cc (740) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
MatrixType.cc (766) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
MatrixType.cc (792) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
MatrixType.cc (818) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
MatrixType.cc (842) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
MatrixType.cc (888) |
V547 | Expression 'typ == MatrixType::Full' is always true. | ||
Range.cc (47) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Range.cc (48) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Range.cc (64) |
V550 | An odd precise comparison: rng_inc != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
Range.cc (66) |
V550 | An odd precise comparison: rng_base == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Range.cc (66) |
V550 | An odd precise comparison: rng_limit == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Range.cc (69) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
Range.cc (350) |
V550 | An odd precise comparison: rng_base != b. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
Range.cc (361) |
V550 | An odd precise comparison: rng_limit != l. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
Range.cc (372) |
V550 | An odd precise comparison: rng_inc != i. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
Range.cc (560) |
V550 | An odd precise comparison: rng_inc == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Sparse.cc (304) |
V778 | Two similar code fragments were found. Perhaps, this is a typo and 'c' variable should be used instead of 'r'. | ||
Sparse-C.cc (49) |
V550 | An odd precise comparison: xabs(a) == xabs(b). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Sparse-C.cc (57) |
V550 | An odd precise comparison: xabs(a) == xabs(b). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Faddeeva.cc (307) |
V550 | An odd precise comparison: y == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Faddeeva.cc (310) |
V550 | An odd precise comparison: x == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Faddeeva.cc (347) |
V550 | An odd precise comparison: y == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Faddeeva.cc (428) |
V550 | An odd precise comparison: x == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Faddeeva.cc (435) |
V550 | An odd precise comparison: y == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Faddeeva.cc (471) |
V550 | An odd precise comparison: y == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Faddeeva.cc (474) |
V550 | An odd precise comparison: x == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Faddeeva.cc (513) |
V550 | An odd precise comparison: x == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Faddeeva.cc (750) |
V1034 | Do not use real type variables as loop counters. | ||
Faddeeva.cc (819) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Faddeeva.cc (830) |
V636 | The 'n * n' expression was implicitly cast from 'int' type to 'double' type. Consider utilizing an explicit type cast to avoid overflow. An example: double A = (double)(X) * Y;. | ||
Faddeeva.cc (848) |
V636 | The 'n * n' expression was implicitly cast from 'int' type to 'double' type. Consider utilizing an explicit type cast to avoid overflow. An example: double A = (double)(X) * Y;. | ||
Faddeeva.cc (867) |
V636 | The 'n * n' expression was implicitly cast from 'int' type to 'double' type. Consider utilizing an explicit type cast to avoid overflow. An example: double A = (double)(X) * Y;. | ||
Faddeeva.cc (884) |
V636 | The 'n * n' expression was implicitly cast from 'int' type to 'double' type. Consider utilizing an explicit type cast to avoid overflow. An example: double A = (double)(X) * Y;. | ||
DASPK.cc (62) |
V707 | Giving short names to global variables is considered to be bad practice. It is suggested to rename 'nn' variable. | ||
DASPK.cc (358) |
V560 | A part of conditional expression is always true: eiq == 3. | ||
DASPK.cc (403) |
V560 | A part of conditional expression is always true: eiq == 3. | ||
DASPK.cc (633) |
V550 | An odd precise comparison: next_crit == next_out. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
DASRT.cc (60) |
V707 | Giving short names to global variables is considered to be bad practice. It is suggested to rename 'nn' variable. | ||
DASRT.cc (478) |
V550 | An odd precise comparison: next_crit == next_out. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
DASSL.cc (57) |
V707 | Giving short names to global variables is considered to be bad practice. It is suggested to rename 'nn' variable. | ||
DASSL.cc (438) |
V550 | An odd precise comparison: next_crit == next_out. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
EIG.cc (136) |
V550 | An odd precise comparison: wi.elem(j) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
EIG.cc (490) |
V550 | An odd precise comparison: ai.elem(j) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
gsvd.cc (535) |
V560 | A part of conditional expression is always false: jobu == 'O'. | ||
gsvd.cc (540) |
V560 | A part of conditional expression is always false: jobv == 'O'. | ||
gsvd.cc (545) |
V560 | A part of conditional expression is always false: jobq == 'O'. | ||
LSODE.cc (440) |
V550 | An odd precise comparison: next_crit == next_out. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
Quad.cc (160) |
V591 | Non-void function should return a value. | ||
Quad.cc (224) |
V591 | Non-void function should return a value. | ||
Quad.cc (230) |
V591 | Non-void function should return a value. | ||
Quad.cc (277) |
V591 | Non-void function should return a value. | ||
Array.h (454) |
V512 | Instantiation of Array <float>: A call of the 'compute_index' function will lead to overflow of the buffer 'ra_idx.data()'. | ||
eigs-base.cc (349) |
V614 | Uninitialized variable 'info' used. | ||
eigs-base.cc (386) |
V614 | Uninitialized variable 'info' used. | ||
eigs-base.cc (430) |
V550 | An odd precise comparison: sigma != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
eigs-base.cc (511) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
eigs-base.cc (530) |
V550 | An odd precise comparison: sigma != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
eigs-base.cc (593) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
eigs-base.cc (612) |
V550 | An odd precise comparison: std::real(sigma) != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
eigs-base.cc (612) |
V550 | An odd precise comparison: std::imag(sigma) != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
eigs-base.cc (694) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
eigs-base.cc (713) |
V550 | An odd precise comparison: std::real(sigma) != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
eigs-base.cc (713) |
V550 | An odd precise comparison: std::imag(sigma) != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
eigs-base.cc (776) |
V550 | An odd precise comparison: rcond_plus_one == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
eigs-base.cc (1393) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(sigma) > Epsilon. | ||
eigs-base.cc (1475) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(std::abs(sigma)) < Epsilon. | ||
eigs-base.cc (1596) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
eigs-base.cc (1619) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
eigs-base.cc (1638) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
eigs-base.cc (1657) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
eigs-base.cc (1706) |
V560 | A part of conditional expression is always true: mode == 1. | ||
eigs-base.cc (1724) |
V560 | A part of conditional expression is always true: mode == 1. | ||
eigs-base.cc (2021) |
V550 | An odd precise comparison: di[i] == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
eigs-base.cc (2397) |
V550 | An odd precise comparison: di[i] == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
eigs-base.cc (2503) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(sigmar) > Epsilon. | ||
eigs-base.cc (2586) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(std::abs(sigmar)) < Epsilon. | ||
eigs-base.cc (2711) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
eigs-base.cc (2734) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
eigs-base.cc (2753) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
eigs-base.cc (2772) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
eigs-base.cc (2840) |
V550 | An odd precise comparison: di[i] == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
eigs-base.cc (3783) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
eigs-base.cc (3806) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
eigs-base.cc (3825) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
eigs-base.cc (3844) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
fEIG.cc (135) |
V550 | An odd precise comparison: wi.elem(j) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
fEIG.cc (484) |
V550 | An odd precise comparison: ai.elem(j) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-mappers.cc (87) |
V550 | An odd precise comparison: std::imag(x) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-mappers.cc (98) |
V550 | An odd precise comparison: std::imag(x) == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-mappers.cc (109) |
V550 | An odd precise comparison: std::imag(x) == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-mappers.cc (120) |
V550 | An odd precise comparison: std::imag(x) == 0.0f. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-mappers.cc (165) |
V550 | An odd precise comparison: ax != lax. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
lo-mappers.cc (173) |
V550 | An odd precise comparison: ax != lax. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
lo-specfun.cc (160) |
V550 | An odd precise comparison: zi == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (230) |
V550 | An odd precise comparison: z.imag() == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (313) |
V550 | An odd precise comparison: zi == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (366) |
V550 | An odd precise comparison: zr == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (366) |
V550 | An odd precise comparison: zi == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (378) |
V550 | An odd precise comparison: zi == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (432) |
V550 | An odd precise comparison: zi == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (490) |
V550 | An odd precise comparison: zr == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (490) |
V550 | An odd precise comparison: zi == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (502) |
V550 | An odd precise comparison: zi == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (872) |
V550 | An odd precise comparison: z.imag() == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (923) |
V550 | An odd precise comparison: z.real() == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (923) |
V550 | An odd precise comparison: z.imag() == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (935) |
V550 | An odd precise comparison: z.imag() == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (988) |
V550 | An odd precise comparison: z.imag() == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (1036) |
V550 | An odd precise comparison: z.real() == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (1036) |
V550 | An odd precise comparison: z.imag() == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (1047) |
V550 | An odd precise comparison: z.imag() == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (1406) |
V550 | An odd precise comparison: zi == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (1477) |
V550 | An odd precise comparison: z.imag() == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (1616) |
V550 | An odd precise comparison: u.real() == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (1728) |
V550 | An odd precise comparison: x == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (1730) |
V550 | An odd precise comparison: x == 2.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (1849) |
V550 | An odd precise comparison: ax == 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (1920) |
V550 | An odd precise comparison: x == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (1924) |
V550 | An odd precise comparison: math::x_nint(x) == x. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (1943) |
V550 | An odd precise comparison: x == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-specfun.cc (1947) |
V550 | An odd precise comparison: math::x_nint(x) == x. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-fftw.cc (116) |
V668 | There is no sense in testing the 'instance' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
oct-fftw.cc (201) |
V656 | Variables 'tmp[i]', 'nn' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'dims(j)' expression. Check lines: 200, 201. | ||
oct-fftw.cc (320) |
V656 | Variables 'tmp[i]', 'nn' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'dims(j)' expression. Check lines: 319, 320. | ||
oct-fftw.cc (476) |
V668 | There is no sense in testing the 'instance' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
oct-fftw.cc (559) |
V656 | Variables 'tmp[i]', 'nn' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'dims(j)' expression. Check lines: 558, 559. | ||
oct-fftw.cc (678) |
V656 | Variables 'tmp[i]', 'nn' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'dims(j)' expression. Check lines: 677, 678. | ||
oct-norm.cc (466) |
V764 | Possible incorrect order of arguments passed to 'dual_p' function: 'q' and 'p'. | ||
oct-rand.cc (67) |
V668 | There is no sense in testing the 'instance' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
oct-spparms.cc (47) |
V668 | There is no sense in testing the 'instance' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
randpoisson.cc (129) |
V550 | An odd precise comparison: my != my_last. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
randpoisson.cc (332) |
V550 | An odd precise comparison: t[tableidx] == t[tableidx - 1]. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
sparse-chol.cc (230) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
sparse-chol.cc (234) |
V550 | An odd precise comparison: spu == 0.. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
sparse-chol.cc (253) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
sparse-chol.cc (254) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
sparse-chol.cc (255) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
sparse-chol.cc (256) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
sparse-chol.cc (257) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
sparse-chol.cc (258) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
sparse-chol.cc (270) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
sparse-chol.cc (271) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
sparse-chol.cc (292) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
sparse-chol.cc (283) |
V506 | Pointer to local variable 'dummy' is stored outside the scope of this variable. Such a pointer will become invalid. | ||
sparse-qr.cc (630) |
V550 | An odd precise comparison: tmp != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
sparse-qr.cc (723) |
V550 | An odd precise comparison: tmp != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
sparse-qr.cc (1294) |
V550 | An odd precise comparison: tmp != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
sparse-qr.cc (1414) |
V550 | An odd precise comparison: tmp != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
sparse-qr.cc (1652) |
V550 | An odd precise comparison: tmp != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
sparse-qr.cc (1756) |
V550 | An odd precise comparison: tmp != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
sparse-qr.cc (1991) |
V550 | An odd precise comparison: tmp != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
sparse-qr.cc (2092) |
V550 | An odd precise comparison: tmp != 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
sparse-qr.cc (2189) |
V524 | It is odd that the body of 'P' function is fully equivalent to the body of 'Pinv' function. | ||
svd.cc (350) |
V560 | A part of conditional expression is always false: jobu == 'O'. | ||
svd.cc (358) |
V560 | A part of conditional expression is always false: jobv == 'O'. | ||
smx-scm-s.cc (12) |
V550 | An odd precise comparison: s != rhs_zero. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
smx-s-scm.cc (12) |
V550 | An odd precise comparison: s != lhs_zero. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
smx-scm-sm.cc (10) |
V501 | There are identical sub-expressions to the left and to the right of the '/' operator: Complex() / Complex() | ||
smx-sm-scm.cc (10) |
V501 | There are identical sub-expressions to the left and to the right of the '/' operator: Complex() / Complex() | ||
lo-sysdep.cc (63) |
V1004 | The 'tmp' pointer was used unsafely after it was verified against nullptr. Check lines: 60, 63. | ||
lo-sysdep.cc (173) |
V575 | The potential null pointer is passed into 'sprintf' function. Inspect the first argument. Check lines: 173, 171. | ||
lo-sysinfo.cc (69) |
V547 | Expression '!retval.empty()' is always false. | ||
oct-env.cc (89) |
V668 | There is no sense in testing the 'instance' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
cmd-edit.cc (538) |
V769 | The 'f' pointer in the 'f - s' expression could be nullptr. In such case, resulting value will be senseless and it should not be used. | ||
cmd-edit.cc (836) |
V575 | The potential null pointer is passed into 'strcpy' function. Inspect the first argument. Check lines: 836, 834. | ||
cmd-edit.cc (857) |
V575 | The potential null pointer is passed into 'strcpy' function. Inspect the first argument. Check lines: 857, 855. | ||
cmd-edit.cc (878) |
V575 | The potential null pointer is passed into 'strcpy' function. Inspect the first argument. Check lines: 878, 876. | ||
cmd-edit.cc (909) |
V519 | The 'matches' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 908, 909. | ||
cmd-edit.cc (1729) |
V547 | Expression 'c == 'A is always true. | ||
cmd-edit.cc (1844) |
V601 | The integer type is implicitly cast to the char type. | ||
cmd-edit.cc (1737) |
V536 | Be advised that the utilized constant value is represented by an octal form. Oct: '\033', Dec: 27. | ||
cmd-edit.cc (1922) |
V536 | Be advised that the utilized constant value is represented by an octal form. Oct: 0777, Dec: 511. | ||
kpse.cc (491) |
V601 | The 'true' value is implicitly cast to the integer type. Inspect the second argument. | ||
kpse.cc (655) |
V601 | The 'true' value is implicitly cast to the integer type. Inspect the second argument. | ||
kpse.cc (784) |
V560 | A part of conditional expression is always true: dir.length() > 0. | ||
kpse.cc (970) |
V560 | A part of conditional expression is always true: !quoted. | ||
lo-array-errwarn.cc (225) |
V550 | An odd precise comparison: n + 1 != nearest. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
lo-array-errwarn.cc (327) |
V550 | An odd precise comparison: rcond == 0.0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-hash.cc (140) |
V591 | Non-void function should return a value. | ||
lo-regexp.cc (127) |
V555 | The expression 'new_pos - pos > 0' will work as 'new_pos != pos'. | ||
lo-regexp.cc (540) |
V1026 | The 'delta' variable is incremented in the loop. Undefined behavior will occur in case of signed integer overflow. | ||
lo-regexp.cc (603) |
V1026 | The 'delta' variable is incremented in the loop. Undefined behavior will occur in case of signed integer overflow. | ||
lo-utils.cc (44) |
V550 | An odd precise comparison: octave::math::x_nint(x) == x. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-utils.cc (47) |
V550 | An odd precise comparison: x == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-utils.cc (47) |
V550 | An odd precise comparison: x == 1. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-utils.cc (50) |
V550 | An odd precise comparison: x == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-utils.cc (65) |
V550 | An odd precise comparison: octave::math::x_nint(x) == x. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-utils.cc (68) |
V550 | An odd precise comparison: x == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-utils.cc (68) |
V550 | An odd precise comparison: x == 1. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-utils.cc (71) |
V550 | An odd precise comparison: x == 0. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
lo-utils.cc (113) |
V575 | The potential null pointer is passed into 'fgets' function. Inspect the first argument. Check lines: 113, 104. | ||
lo-utils.cc (129) |
V769 | The 'buf' pointer in the 'buf + tmp' expression could be nullptr. In such case, resulting value will be senseless and it should not be used. Check lines: 129, 122. | ||
oct-inttypes.cc (233) |
V550 | An odd precise comparison: xx != y. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
oct-inttypes.cc (238) |
V550 | An odd precise comparison: xx == xxup. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-inttypes.cc (254) |
V550 | An odd precise comparison: xx != y. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
oct-inttypes.cc (259) |
V550 | An odd precise comparison: xx == xxup. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-inttypes.cc (261) |
V550 | An odd precise comparison: xx == xxlo. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-inttypes.cc (582) |
V550 | An odd precise comparison: y == octave::math::fix(y). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-inttypes.cc (584) |
V550 | An odd precise comparison: y == 0.5. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-inttypes.cc (617) |
V550 | An odd precise comparison: y == octave::math::fix(y). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-inttypes.cc (619) |
V550 | An odd precise comparison: fabs(y) == 0.5. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-inttypes.cc (667) |
V550 | An odd precise comparison: y == octave::math::fix(y). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-inttypes.cc (677) |
V550 | An odd precise comparison: y == octave::math::fix(y). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-inttypes.cc (754) |
V550 | An odd precise comparison: b == octave::math::fix(b). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-inttypes.cc (769) |
V550 | An odd precise comparison: b == octave::math::fix(b). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-inttypes.cc (787) |
V550 | An odd precise comparison: b == octave::math::fix(b). It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
oct-inttypes.cc (784) |
V524 | It is odd that the body of 'powf' function is fully equivalent to the body of 'pow' function. | ||
oct-mutex.cc (45) |
V524 | It is odd that the body of 'unlock' function is fully equivalent to the body of 'lock' function. | ||
singleton-cleanup.cc (48) |
V668 | There is no sense in testing the 'instance' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
oct-rl-edit.c (201) |
V575 | The potential null pointer is passed into 'strcpy' function. Inspect the first argument. Check lines: 201, 201. | ||
oct-rl-edit.c (293) |
V575 | The potential null pointer is passed into 'strcpy' function. Inspect the first argument. Check lines: 293, 293. | ||
oct-rl-edit.c (301) |
V575 | The potential null pointer is passed into 'strcpy' function. Inspect the first argument. Check lines: 301, 301. | ||
oct-rl-edit.c (321) |
V575 | The potential null pointer is passed into 'strcpy' function. Inspect the first argument. Check lines: 321, 321. | ||
oct-rl-edit.c (329) |
V575 | The potential null pointer is passed into 'strcpy' function. Inspect the first argument. Check lines: 329, 329. | ||
oct-rl-edit.c (337) |
V575 | The potential null pointer is passed into 'strcpy' function. Inspect the first argument. Check lines: 337, 337. | ||
oct-rl-edit.c (435) |
V575 | The potential null pointer is passed into 'strcpy' function. Inspect the first argument. Check lines: 435, 435. | ||
oct-rl-hist.c (61) |
V526 | The 'strcmp' function returns 0 if corresponding strings are equal. Consider examining the condition for mistakes. | ||
oct-rl-hist.c (279) |
V1028 | Possible overflow. Consider casting operands of the 'end - beg + 1' operator to the 'size_t' type, not the result. | ||
oct-rl-hist.c (289) |
V575 | The potential null pointer is passed into 'sprintf' function. Inspect the first argument. Check lines: 289, 286. | ||
oct-rl-hist.c (294) |
V522 | There might be dereferencing of a potential null pointer 'retval'. Check lines: 294, 279. | ||
octave-config.cc (109) |
V656 | Variables 'vars["DATADIR"]', 'vars["DATAROOTDIR"]' are initialized through the call to the same function. It's probably an error or un-optimized code. Consider inspecting the 'prepend_octave_home("share")' expression. Check lines: 108, 109. | ||
BlockArray.h (32) |
V730 | Not all members of a class are initialized inside the constructor. Consider inspecting: data. | ||
CharacterColor.h (44) |
V690 | The 'ColorEntry' class implements the '=' operator, but lacks a copy constructor. It is dangerous to use such a class. | ||
CharacterColor.h (261) |
V640 | The code's operational logic does not correspond with its formatting. The second statement will always be executed. It is possible that curly brackets are missing. | ||
Emulation.cpp (165) |
V547 | Expression 'codec == LocaleCodec' is always true. | ||
Emulation.cpp (266) |
V688 | The '_decoder' function argument possesses the same name as one of the class members, which can result in a confusion. | ||
Filter.cpp (490) |
V523 | The 'then' statement is equivalent to the 'else' statement. | ||
History.cpp (83) |
V730 | Not all members of a class are initialized inside the constructor. Consider inspecting: readWriteBalance. | ||
KeyboardTranslator.cpp (72) |
V519 | The 'list' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 69, 72. | ||
KeyboardTranslator.cpp (702) |
V576 | Incorrect format. Consider checking the third actual argument of the 'sscanf' function. A pointer to the unsigned int type is expected. | ||
Screen.cpp (304) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
Screen.cpp (315) |
V601 | The 'false' value is implicitly cast to the integer type. | ||
Screen.cpp (1033) |
V688 | The 'lines' local variable possesses the same name as one of the class members, which can result in a confusion. | ||
ScreenWindow.cpp (208) |
V547 | Expression 'mode == ScrollPages' is always true. | ||
ScreenWindow.cpp (182) |
V524 | It is odd that the body of 'columnCount' function is fully equivalent to the body of 'windowColumns' function. | ||
ScreenWindow.cpp (31) |
V730 | Not all members of a class are initialized inside the constructor. Consider inspecting: _screen. | ||
Vt102Emulation.cpp (1164) |
V560 | A part of conditional expression is always false: m == 5. | ||
Vt102Emulation.cpp (1187) |
V560 | A part of conditional expression is always false: m == 5. | ||
TerminalView.cpp (587) |
V547 | Expression '_cursorShape == IBeamCursor' is always true. | ||
TerminalView.cpp (856) |
V688 | The '_clipboard' local variable possesses the same name as one of the class members, which can result in a confusion. | ||
TerminalView.cpp (887) |
V601 | The 'true' value is implicitly cast to the integer type. | ||
TerminalView.cpp (942) |
V519 | The '_fixedFont' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 938, 942. | ||
TerminalView.cpp (1669) |
V728 | An excessive check can be simplified. The '||' operator is surrounded by opposite expressions '_mouseMarks' and '!_mouseMarks'. | ||
TerminalView.cpp (1835) |
V550 | An odd precise comparison. It's probably better to use a comparison with defined precision: fabs(A - B) < Epsilon. | ||
TerminalView.cpp (2261) |
V547 | Expression '_tripleClickMode == SelectWholeLine' is always true. | ||
moc-SelfListener.cc (112) |
V688 | The '_a' function argument possesses the same name as one of the class members, which can result in a confusion. | ||
moc-SelfListener.cc (132) |
V688 | The '_a' local variable possesses the same name as one of the class members, which can result in a confusion. | ||
dialog.cc (468) |
V522 | There might be dereferencing of a potential null pointer 'resource_manager::get_settings()'. | ||
dialog.cc (543) |
V519 | The 'idx' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 520, 543. | ||
documentation.cc (70) |
V522 | There might be dereferencing of a potential null pointer 'getenv("OCTAVE_QTHELP_COLLECTION")'. A constructor of the string class expects a valid pointer. | ||
documentation.cc (96) |
V595 | The 'm_help_engine' pointer was utilized before it was verified against nullptr. Check lines: 96, 110. | ||
external-editor-interface.cc (101) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
files-dock-widget.cc (190) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
files-dock-widget.cc (406) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
files-dock-widget.cc (436) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
files-dock-widget.cc (472) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
files-dock-widget.cc (857) |
V522 | There might be dereferencing of a potential null pointer 'resource_manager::get_settings()'. | ||
history-dock-widget.cc (318) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
file-editor.h (412) |
V703 | It is odd that the 'm_close_action' field in derived class 'file_editor' overwrites field in base class 'label_dock_widget'. Check lines: file-editor.h:412, octave-dock-widget.h:72. | ||
file-editor-tab.cc (207) |
V601 | The 'false' value is implicitly cast to the integer type. Inspect the second argument. | ||
file-editor-tab.cc (236) |
V1004 | The 'settings' pointer was used unsafely after it was verified against nullptr. Check lines: 226, 236. | ||
file-editor-tab.cc (407) |
V565 | An empty exception handler. Silent suppression of exceptions can hide the presence of bugs in source code during testing. | ||
file-editor-tab.cc (408) |
V565 | An empty exception handler. Silent suppression of exceptions can hide the presence of bugs in source code during testing. | ||
file-editor-tab.cc (622) |
V668 | There is no sense in testing the 'lexer' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
file-editor-tab.cc (654) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
file-editor-tab.cc (1446) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
file-editor-tab.cc (1911) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
file-editor-tab.cc (1998) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
file-editor-tab.cc (2029) |
V565 | An empty exception handler. Silent suppression of exceptions can hide the presence of bugs in source code during testing. | ||
file-editor-tab.cc (2245) |
V522 | There might be dereferencing of a potential null pointer 'resource_manager::get_settings()'. | ||
file-editor-tab.cc (2611) |
V601 | The 'true' value is implicitly cast to the integer type. Inspect the second argument. | ||
file-editor.cc (206) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
file-editor.cc (413) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
file-editor.cc (449) |
V668 | There is no sense in testing the 'fileEditorTab' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
file-editor.cc (1270) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
file-editor.cc (1330) |
V668 | There is no sense in testing the 'fileEditorTab' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
file-editor.cc (1549) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
file-editor.cc (1623) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
file-editor.cc (2373) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
file-editor.cc (2383) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
file-editor.cc (2401) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
octave-qscintilla.cc (122) |
V601 | The 'false' value is implicitly cast to the integer type. Inspect the second argument. | ||
octave-qscintilla.cc (396) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
ui-settings-dialog.h (40) |
V553 | The length of 'Ui_settings_dialog' class's declaration is more than 2000 lines long. You should consider refactoring the code. | ||
main-window.cc (366) |
V522 | There might be dereferencing of a potential null pointer 'dock'. | ||
main-window.cc (394) |
V522 | There might be dereferencing of a potential null pointer 'resource_manager::get_settings()'. | ||
main-window.cc (414) |
V522 | There might be dereferencing of a potential null pointer 'resource_manager::get_settings()'. | ||
main-window.cc (852) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
main-window.cc (910) |
V522 | There might be dereferencing of a potential null pointer 'resource_manager::get_settings()'. | ||
main-window.cc (1066) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
main-window.cc (1081) |
V522 | There might be dereferencing of a potential null pointer 'resource_manager::get_settings()'. | ||
main-window.cc (1108) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
main-window.cc (1615) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
main-window.cc (2450) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
main-window.cc (2557) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
octave-dock-widget.cc (312) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
octave-gui.cc (42) |
V730 | Not all members of a class are initialized inside the constructor. Consider inspecting: m_argc, m_argv. | ||
resource-manager.cc (179) |
V668 | There is no sense in testing the 'instance' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
resource-manager.cc (297) |
V668 | There is no sense in testing the 'm_settings' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
settings-dialog.cc (550) |
V522 | There might be dereferencing of a potential null pointer 'resource_manager::get_settings()'. | ||
settings-dialog.cc (816) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
shortcut-manager.cc (175) |
V668 | There is no sense in testing the 'instance' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
shortcut-manager.cc (678) |
V522 | There might be dereferencing of a potential null pointer 'resource_manager::get_settings()'. | ||
shortcut-manager.cc (698) |
V668 | There is no sense in testing the 'osc_settings' pointer against null, as the memory was allocated using the 'new' operator. The exception will be generated in the case of memory allocation error. | ||
shortcut-manager.cc (97) |
V730 | It is possible that not all members of a class are initialized inside the constructor. Consider inspecting: m_dialog, m_edit_actual, m_label_default, m_handled_index. | ||
terminal-dock-widget.cc (67) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
find-files-dialog.cc (69) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
find-files-dialog.cc (318) |
V522 | There might be dereferencing of a potential null pointer 'resource_manager::get_settings()'. | ||
workspace-model.cc (42) |
V730 | It is possible that not all members of a class are initialized inside the constructor. Consider inspecting: m_top_level, m_enable_colors. | ||
workspace-view.cc (178) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
workspace-view.cc (309) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
workspace-view.cc (323) |
V522 | There might be dereferencing of a potential null pointer 'settings'. | ||
variable-editor.cc (449) |
V522 | There might be dereferencing of a potential null pointer 'resource_manager::get_settings()'. | ||
octave-svgconvert.cc (483) |
V550 | An odd precise comparison: str.toDouble() != 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
octave-svgconvert.cc (518) |
V550 | An odd precise comparison: pat[1] != 0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
octave-svgconvert.cc (577) |
V550 | An odd precise comparison: str.toDouble() != 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
octave-svgconvert.cc (660) |
V550 | An odd precise comparison: alpha != 1.0. It's probably better to use a comparison with defined precision: fabs(A - B) > Epsilon. | ||
octave-svgconvert.cc (89) |
V524 | It is odd that the body of 'qstr2vectord' function is fully equivalent to the body of 'qstr2vectorf' function. | ||