买彩票那个数字容易中奖

Skip navigation

SEGGER Floating-Point Library

Optimized floating-point library for embedded systems

  • High performance C implementation
  • Assembly-optimized variants for RISC-V and Arm available
  • Significant code size reduction
  • Configurable for high speed or small size
  • Designed for use with various toolchains
  • EABI compatible functions
  • No heap requirements
  • No viral licensing, no attribution clause

 contents

 
[show]
[hide]

买彩票那个数字容易中奖the segger floating-point library is an essential part of the segger runtime library. it is available stand-alone or as part of the segger runtime library package, and already included in the use of segger embedded studio.

买彩票那个数字容易中奖the floating-point library contains complete, fully optimized and verified floating point functionality, which is required for devices without an fpu. the floating-point emulator, a crucial part of the floating-point library, of the arm and risc-v variants are written in assembly language, optimized either for small code size or increased execution speed. for other processor architectures the library has a portable c implementation.

买彩票那个数字容易中奖the assembly language versions have multiple implementations of basic operations using instructions and algorithms that make best use of the integer arithmetic instructions available in the architecture. for instance, for single precision division:

  • Use a division instruction to iteratively develop a quotient, if available.
  • If no division instruction, but there is a multiplication instruction, use an initial reciprocal approximation refined by Newton-Raphson iterations with a final correction and multiplication.
  • If no division and no multiplication instruction, use a non-restoring division algorithm.

买彩票那个数字容易中奖similar optimizations apply to double-precision division.

where appropriate, integer approximations for elementary functions are used that produce correct results within 0.5 units in the last place.

买彩票那个数字容易中奖the floating-point library provides a consistent execution environment that ensures that infinities, not-a-number, and zero results with correct sign are accepted as inputs and generated as outputs. to be consistent with floating-point units executing in fast mode, the library elects to flush subnormals to a correctly-signed zero. because subnormals do not typically occur in embedded systems, this optimization enables significant code size reduction.

For details on what makes a thoughtfully designed runtime library different from a run-of-the-mill runtime library, refer to SEGGER Runtime Library webpage: http://gsclbkb.cn/runtime-library

Implementation and Design

买彩票那个数字容易中奖the floating-point library has been designed and developed for the use on microcontrollers. as part of the segger runtime library, which is part of embedded studio, the floating-point library exists for a long time. now it is available as a stand-alone version for developers who do not want to replace the entire runtime library of their system but want to focus on performance, size, and accuracy of the floating-point implementation.

the floating-point library has gone through multiple development cycles over time, being further optimized on both levels, design level (using efficient algorithms) as well as implementation level (running on different architectures). it implements most efficient algorithms in generic c-code, with assembly code implementations optimized for the specific architectures. the source code contains options to tune it for high performance or small code size, delivering excellent performance in any case.

 

Use Cases

the segger floating-point library is available for integration into specific projects by end users, as well as to tool chain builds that want to deliver a top notch runtime and/or floating-point library to their users.

licensing options to fit any of such needs are available, usually with a one-off payment and no royalties.

Deliverables

the segger floating-point library is delivered in source code, with optional rights for redistribution in object code form. all source files, a mix of c code and assembly, are fully commented.

the floating-point emulator, providing the low-level functions, is entirely written in assembly. higher level functions are implemented as a mix of primarily c code with some assembly routines. the code can be compiled with any anso-compliant c compiler, such as gcc, clang, or iar.

 

Integration and Use

the segger floating-point library provides all well-known floating-point-related api functions of c standard libraries, as well as floating-point-operation functions defined by the architecture's eabi which are implicitly called and added by the compiler.

买彩票那个数字容易中奖the segger floating-point library can either be integrated into a toolchain to replace the existing standard library implementation, or it can be used side-by-side. the side-by-side use enables selective calls to the floating-point library, while retaining the toolchain' standard library, which makes the integration and use easy and simple.

Example

买彩票那个数字容易中奖to return the sine of a value x:

  • With the integrated use, call sin(x).
  • With the side-by-side use, call SEGGER_sin(x).

买彩票那个数字容易中奖to multiply two float values a and b without the use of an fpu:

  • With the integrated use, call A * B, for which the compiler will implicitly call __mulsf3(A, B) or __aeabi_fmul(A, B).
  • With the side-by-side use, call SEGGER_fmul(A,B)

Variants

the segger floating-point library is available in a universal variant written in c, and specific variants for different cpus. the specific variants include modules written in assembly language, optimized for the cpu architecture, and deliver a higher performance than the universial c variant.

Universal C variant

买彩票那个数字容易中奖the universal version is written in c. the performance is highly optimized and much higher than the performance of comparable, c-coded open source implementations.

Supported CPUs

the universal variant can be used on any platform, including 8-, 16-, 32, and 64- bit processors.

Arm Variant

the arm-optimized variant is fully coded in assembly language, conforming to the aeabi.this means it is compatible with any (a)eabi compliant tool chain, including any gcc, llvm/clang based tool chains as well as arm's own compiler (incl. keil) and iar and can replace the default runtime library or parts of it.

Supported CPUs

买彩票那个数字容易中奖the arm variant supports any 32-bit arm cpu, starting from arm architecture v4. this includes cortex-m, cortex-a, and cortex-r.

RISC-V Variant

the risc-v variant is written in assembly language, providing functions compatible with the eabi. it can easily be used to replace the default runtime library of eabi compliant toolchains. 

Supported CPUs

the risc-v variant supports rv32i with architecture-specific acceleration.  i supports faster multiply and divide with the m (multiply/divide) extension.  it also supports fast division even if if the m extension lacks a divide instruction.

Architecture-specific Optimization

买彩票那个数字容易中奖the assembly language variants of the segger floating-point library take advantage of the processor-specific features. each architecture has its own tuned implementation.

买彩票那个数字容易中奖in the arm variant, the floating-point support makes use of the thumb-2 instruction set and uses divide instructions and extended multiply instructions, when available, which results in a smaller and faster implementation. pure thumb instruction sets, such as on cortex-m0 and cortex-m23 processors, are, of course, supported entirely, too. the floating-point implementation also supports execute-only code regions where no constant data values are read from memory.

in the risc-v variant, software floating-point is supported on all rv32i architectures. the floating-point implementation takes full full advantage of processors that have the m extension, and processors that have the m extension but without a divide instruction. the c extension is supported to select registers that make the best use of the compact instruction encoding, achieving smaller code.

Configuration Options

the segger floating-point library is highly optimized to get the best performance in the generic part and on the specific architectures.

In the source distribution, the library can be configured and tuned to favor faster or smaller code with different levels of optimization:
-2 - Favor size at the expense of speed
-1 - Favor size over speed
0 - Balanced
+1 - Favor speed over size
+2 - Favor speed at the expense of size

The sections below show the performance of the high-level explicit functions and the low-level implicit floating-point functions of different architectures. For more information refer to the blog post 

Note: Due to the specific features of each architecture, the performance values should not be compared to each other. Instead these values are generated for comparison with other floating-point libraries.

API Functions

Explicit Functions

买彩票那个数字容易中奖the floating-point library implements all standard library functions which are usually exposed through math.h. these functions are always explicitly called by a user application.

with the integrated use of the library, the standard function can simply be called (no prefix), with the side-by-side use, the functions of this library can be called instead of the standard library implementation by adding the prefix "segger_". the api interface is compatible.

Function List

 

int                SEGGER_isinff        (float  x);
int                SEGGER_isinf         (double x);
int                SEGGER_isnanf        (float  x);
int                SEGGER_isnan         (double x);
int                SEGGER_isfinitef     (float  x);
int                SEGGER_isfinite      (double x);
int                SEGGER_isnormalf     (float  x);
int                SEGGER_isnormal      (double x);
int                SEGGER_signbitf      (float  x);
int                SEGGER_signbit       (double x);
int                SEGGER_classifyf     (float  x);
int                SEGGER_classify      (double x);
float              SEGGER_cosf          (float  x);
double             SEGGER_cos           (double x);
float              SEGGER_sinf          (float  x);
double             SEGGER_sin           (double x);
float              SEGGER_tanf          (float  x);
double             SEGGER_tan           (double x);
float              SEGGER_acosf         (float  x);
double             SEGGER_acos          (double x);
float              SEGGER_asinf         (float  x);
double             SEGGER_asin          (double x);
float              SEGGER_atanf         (float  x);
double             SEGGER_atan          (double x);
float              SEGGER_atan2f        (float  y, float  x);
double             SEGGER_atan2         (double y, double x);
float              SEGGER_frexpf        (float  x, int *exp);
double             SEGGER_frexp         (double x, int *exp);
float              SEGGER_ldexpf        (float  x, int exp);
double             SEGGER_ldexp         (double x, int exp);
float              SEGGER_scalbnf       (float  x, int exp);
double             SEGGER_scalbn        (double x, int exp);
float              SEGGER_logf          (float  x);
double             SEGGER_log           (double x);
float              SEGGER_log10f        (float  x);
double             SEGGER_log10         (double x);
float              SEGGER_fmodf         (float  x, float  y);
double             SEGGER_fmod          (double x, double y);
float              SEGGER_modff         (float  x, float  *iptr);
double             SEGGER_modf          (double x, double *iptr);
float              SEGGER_powf          (float  x, float  y);
double             SEGGER_pow           (double x, double y);
float              SEGGER_sqrtf         (float  x);
double             SEGGER_sqrt          (double x);
float              SEGGER_cbrtf         (float  x);
double             SEGGER_cbrt          (double x);
float              SEGGER_ceilf         (float  x);
double             SEGGER_ceil          (double x);
float              SEGGER_fabsf         (float  x);
double             SEGGER_fabs          (double x);
float              SEGGER_fminf         (float  x, float  y);
double             SEGGER_fmin          (double x, double y);
float              SEGGER_fmaxf         (float  x, float  y);
double             SEGGER_fmax          (double x, double y);
float              SEGGER_floorf        (float  x);
double             SEGGER_floor         (double x);
float              SEGGER_hypotf        (float  x, float  y);
double             SEGGER_hypot         (double x, double y);
float              SEGGER_coshf         (float  x);
double             SEGGER_cosh          (double x);
float              SEGGER_sinhf         (float  x);
double             SEGGER_sinh          (double x);
float              SEGGER_tanhf         (float  x);
double             SEGGER_tanh          (double x);
float              SEGGER_expf          (float  x);
double             SEGGER_exp           (double x);
float              SEGGER_expm1f        (float  x);
float              SEGGER_acoshf        (float  x);
double             SEGGER_acosh         (double x);
float              SEGGER_asinhf        (float  x);
double             SEGGER_asinh         (double x);
float              SEGGER_atanhf        (float  x);
double             SEGGER_atanh         (double x);
float              SEGGER_fmaf          (float  x, float  y, float  z);
double             SEGGER_fma           (double x, double y, double z);
float              SEGGER_exp2f         (float  x);
double             SEGGER_exp2          (double x);
float              SEGGER_exp10f        (float  x);
double             SEGGER_exp10         (double x);
float              SEGGER_expm1f        (float  x);
double             SEGGER_expm1         (double x);
float              SEGGER_log1pf        (float  x);
double             SEGGER_log1p         (double x);
float              SEGGER_log2f         (float  x);
double             SEGGER_log2          (double x);
float              SEGGER_logbf         (float  x);
double             SEGGER_logb          (double x);

Implicit Functions

when there is no hardware support for basic operations, such as multiplication of two floats, the compiler adds calls to helper functions emulating the operation with available resources. these are the implicit functions, defined by the toolchain's and architecture's eabi.

with the integrated use of the specific variants of segger floating-point library, the compiler will use its implicit functions. when used side-by-side, the functions can be explicitly called instead of writing the standard operation in code.

Function List

 

float              SEGGER_addf          (float, float);
double             SEGGER_add           (double, double);
float              SEGGER_subf          (float, float);
double             SEGGER_sub           (double, double);
float              SEGGER_mulf          (float, float);
double             SEGGER_mul           (double, double);
float              SEGGER_divf          (float, float);
double             SEGGER_div           (double, double);
int                SEGGER_ltf           (float, float);
int                SEGGER_lt            (double, double);
int                SEGGER_lef           (float, float);
int                SEGGER_le            (double, double);
int                SEGGER_gtf           (float, float);
int                SEGGER_gt            (double, double);
int                SEGGER_gef           (float, float);
int                SEGGER_ge            (double, double);
int                SEGGER_eqf           (float, float);
int                SEGGER_eq            (double, double);
int                SEGGER_nef           (float, float);
int                SEGGER_ne            (double, double);
float              SEGGER_float_int     (int);
double             SEGGER_double_int    (int);
float              SEGGER_float_llong   (long long);
double             SEGGER_double_llong  (long long);
float              SEGGER_float_uint    (unsigned);
double             SEGGER_double_uint   (unsigned);
float              SEGGER_float_ullong  (unsigned long long);
double             SEGGER_double_ullong (unsigned long long);
int                SEGGER_int_float     (float);
int                SEGGER_int_double    (double);
long long          SEGGER_llong_float   (float);
long long          SEGGER_llong_double  (double);
unsigned           SEGGER_uint_float    (float);
unsigned           SEGGER_uint_double   (double);
unsigned long long SEGGER_ullong_float  (float);
unsigned long long SEGGER_ullong_double (double);
float              SEGGER_float_double  (double);
double             SEGGER_double_float  (float);

Explicit Function Performance

买彩票那个数字容易中奖for verification and benchmark of the explicit functions, the ieee-754 floating-point library benchmark application is available. it measures performance and precision of the implementation. for each function, significant values have been chosen to get best coverage.

the tables below show the results of the benchmark application running the c implementation on different architectures.

Performance on Arm

买彩票那个数字容易中奖the benchmark has been done on an arm cortex-m4 microcontroller (nxp k66fn2m0), running from ram. detailed results and test cases are available on the .

sinf()Bit ErrorCycles
sin(1e-4) 0.0021
sin(1e-3) 0.00 55
sin(1e-2) 0.00 55
sin(1e-1) 0.00 54
sin(1) 0.00139
sin(1.47264147) 0.00138
sin(1.57079089) 0.00138
sinf(3.14158154)0.00106
sin(39.0735703) 0.00148
sin(355) 0.00152
sin(1048582.75) 0.00176
sin(100000*Pi) 0.00151
sin(1e10) 0.00187
sin(1e38) 0.00186
Total 0.001706
cosf()Bit ErrorCycles
cos(1e-4) 0.00 3
cos(1e-3) 0.00 48
cos(1e-2) 0.00 48
cos(1e-1) 0.00 48
cos(1) 0.00136
cos(1.47264147)0.00103
cos(1.57079780)0.00103
cos(6.28319073)0.00136
cos(355) 0.00180
cos(100000*Pi) 0.00180
cos(1e10) 0.00183
cos(1e38) 0.00182
Total 0.001350
tanf()Bit ErrorCycles
tan(1e-4) 0.0025
tan(1e-3) 0.00 74
tan(1e-2) 0.00 74
tan(1e-1) 0.00 73
tan(1) 0.00258
tan(6.45840693)0.00258
tan(355) 0.00282
tan(100000*Pi) 0.00273
tan(1e10) 0.00304
tan(1e38) 0.00321
Total 0.001942
expf()Bit ErrorCycles
expf(0) 0.003
expf(1e-5) 0.0044
expf(1e-4) 0.0044
expf(2e-4) 0.0044
expf(4e-4) 0.0043
expf(4.5e-4) 0.0044
expf(1e-3) 0.0044
expf(0.25123) 0.0081
expf(0.55123) 0.0080
expf(8.1) 0.0081
expf(16.1) 0.0081
Total 0.00589
sinhf()Bit ErrorCycles
sinhf(1e-5) 0.00 22
sinhf(1e-4) 0.00 23
sinhf(2e-4) 0.00 23
sinhf(4e-4) 0.00 60
sinhf(4.5e-4) 0.00 59
sinhf(1e-3) 0.00 60
sinhf(0.25123) 0.00 60
sinhf(0.55123) 0.00119
sinhf(8.1) 0.00121
sinhf(16.1) 0.00108
Total 0.00655
coshf()Bit ErrorCycles
coshf(1e-5) 0.00 28
coshf(1e-4) 0.00 28
coshf(2e-4) 0.00 29
coshf(4e-4) 0.00 48
coshf(4.5e-4) 0.00 48
coshf(1e-3) 0.00 47
coshf(0.25123) 0.00 48
coshf(0.55123) 0.00111
coshf(8.1) 0.00114
coshf(16.1) 0.00100
Total 0.00601
tanhf()Bit ErrorCycles
tanhf(0.25) 0.00 66
tanhf(1) 0.00108
tanhf(10) 0.00 18
Total 0.00192
logf()Bit ErrorCycles
logf(1e-5) 0.00158
logf(1024) 0.00100
logf(4177.25) 0.00140
Total 0.00398

Performance on RISC-V

买彩票那个数字容易中奖the benchmark has been done on an risc-v rv32imac microcontroller (gigadevice gd32vf103), running from ram. detailed results and test cases are available on the .

sinf()Bit ErrorCycles
sin(1e-4) 0.00 8
sin(1e-3) 0.00 70
sin(1e-2) 0.00 67
sin(1e-1) 0.00 67
sin(1) 0.00182
sin(1.47264147) 0.00193
sin(1.57079089) 0.00196
sinf(3.14158154)0.00153
sin(39.0735703) 0.00193
sin(355) 0.00219
sin(1048582.75) 0.00236
sin(100000*Pi) 0.00214
sin(1e10) 0.00255
sin(1e38) 0.00248
Total 0.002301
cosf()Bit ErrorCycles
cos(1e-4) 0.00 10
cos(1e-3) 0.00 50
cos(1e-2) 0.00 43
cos(1e-1) 0.00 43
cos(1) 0.00186
cos(1.47264147)0.00158
cos(1.57079780)0.00161
cos(6.28319073)0.00190
cos(355) 0.00252
cos(100000*Pi) 0.00251
cos(1e10) 0.00245
cos(1e38) 0.00257
Total 0.001846
tanf()Bit ErrorCycles
tan(1e-4) 0.00 7
tan(1e-3) 0.00 92
tan(1e-2) 0.00 87
tan(1e-1) 0.00 86
tan(1) 0.00403
tan(6.45840693)0.00397
tan(355) 0.00444
tan(100000*Pi) 0.00430
tan(1e10) 0.00458
tan(1e38) 0.00483
Total 0.002887
expf()Bit ErrorCycles
expf(0) 0.0010
expf(1e-5) 0.0045
expf(1e-4) 0.0041
expf(2e-4) 0.0038
expf(4e-4) 0.0038
expf(4.5e-4) 0.0038
expf(1e-3) 0.0038
expf(0.25123) 0.0086
expf(0.55123) 0.0089
expf(8.1) 0.0088
expf(16.1) 0.0086
Total 0.00597
sinhf()Bit ErrorCycles
sinhf(1e-5) 0.00 14
sinhf(1e-4) 0.00 14
sinhf(2e-4) 0.00 13
sinhf(4e-4) 0.00 67
sinhf(4.5e-4) 0.00 59
sinhf(1e-3) 0.00 59
sinhf(0.25123) 0.00 59
sinhf(0.55123) 0.00137
sinhf(8.1) 0.00133
sinhf(16.1) 0.00112
Total 0.00667
coshf()Bit ErrorCycles
coshf(1e-5) 0.00 26
coshf(1e-4) 0.00 24
coshf(2e-4) 0.00 24
coshf(4e-4) 0.00 50
coshf(4.5e-4) 0.00 50
coshf(1e-3) 0.00 50
coshf(0.25123) 0.00 50
coshf(0.55123) 0.00140
coshf(8.1) 0.00139
coshf(16.1) 0.00126
Total 0.00679
tanhf()Bit ErrorCycles
tanhf(0.25) 0.00 89
tanhf(1) 0.00145
tanhf(10) 0.00 14
Total 0.00248
logf()Bit ErrorCycles
logf(1e-5) 0.00265
logf(1024) 0.00183
logf(4177.25) 0.00240
Total 0.00688

Implicit Function Performance

买彩票那个数字容易中奖the following tables show the performance and code size of the arm and risc-v eabi floating-point functions.  

The performance benchmark runs the speed-optimized implementation of the floating-point library (__SEGGER_RTL_OPTIMIZE +2).
买彩票那个数字容易中奖The code size has been measured with size optimization (__SEGGER_RTL_OPTIMIZE -2). The speed-optimized configuration requires slightly more code.

Performance on Arm

买彩票那个数字容易中奖the benchmarks have been done on an arm cortex-m4 microcontroller (nxp k66fn2m0), running from ram, compiled with embedded studio (gcc).

FunctionAverage Cycles
Float, Math__aeabi_fadd31.0
__aeabi_fsub39.9
__aeabi_frsub39.9
__aeabi_fmul26.0
__aeabi_fdiv53.0
Float, Compare__aeabi_fcmplt13.0
__aeabi_fcmple13.0
__aeabi_fcmpgt13.0
__aeabi_fcmpge13.0
__aeabi_fcmpeq7.0
Double, Math__aeabi_dadd54.5
__aeabi_dsub71.2
__aeabi_drsub71.2
__aeabi_dmul56.4
__aeabi_ddiv134.0
Double, Compare__aeabi_dcmplt14.0
__aeabi_dcmple14.0
__aeabi_dcmpgt14.0
__aeabi_dcmpge14.0
__aeabi_dcmpeq14.0
Float, Conversion__aeabi_f2iz9.0
__aeabi_f2uiz6.0
__aeabi_f2lz13.5
__aeabi_f2ulz12.0
__aeabi_i2f10.5
__aeabi_ui2f7.5
__aeabi_l2f19.0
__aeabi_ul2f13.8
__aeabi_f2d9.0
Double, Conversion__aeabi_d2iz10.0
__aeabi_d2uiz8.0
__aeabi_d2lz16.5
__aeabi_d2ulz13.5
__aeabi_i2d12.0
__aeabi_ui2d8.0
__aeabi_l2d17.9
__aeabi_ul2d12.9
__aeabi_d2f11.0

EABI Function Performance on RISC-V

the benchmarks have been done on a gd32vd107 (rv32imac), running from flash, compiled with embedded studio (gcc), optimized for speed.

FunctionCycles, MinCycles, MaxCycles, Avg
Float, Math__addsf345 60 49.5
__subsf342 84 62.2
__mulsf337 57 39.3
__divsf367 70 67.0
Float, Compare__ltsf211 15 11.0
__lesf210 14 10.0
__gtsf210 17 10.0
__gesf211 14 11.0
__eqsf210 13 10.0
__nesf210 10 10.0
Double, Math__adddf352 89 62.8
__subdf360 12382.8
__muldf368 88 75.0
__divdf3192204197.2
Double, Compare__ltdf215 20 16.0
__ledf215 19 16.0
__gtdf215 20 16.1
__gedf215 19 16.1
__eqdf214 17 14.0
__nedf214 14 14.0
Float, Conversion__fixsfsi14 14 14.0
__fixunssfsi13 13 13.0
__fixsfdi20 29 23.2
__fixunssfdi15 23 18.9
__floatsisf28 47 32.6
__floatunsisf28 42 33.0
__floatdisf39 66 49.1
__floatundisf35 58 44.1
__extendsfdf214 18 14.1
Double, Conversion__fixdfsi9 20 16.8
__fixunsdfsi9 14 13.8
__fixdfdi9 34 26.9
__fixunsdfdi9 25 21.5
__floatsidf28 47 31.6
__floatunsidf19 32 23.9
__floatdidf30 73 45.1
__floatundidf27 62 39.3
__truncdfsf225 36 25.1

EABI Function Code Size on RISC-V

买彩票那个数字容易中奖for function code size, the floating-point library has been compiled with optimization for size, targeting rv32imc.

FunctionCode Size [Bytes]
Float, Math__addsf3410
__subsf310
__mulsf3178
__divsf3184
Float, Compare__ltsf258
__lesf254
__gtsf250
__gesf262
__eqsf244
__nesf2--
Double, Math__adddf3724
__subdf310
__muldf3286
__divdf3278
Double, Compare__ltdf270
__ledf270
__gtdf270
__gedf270
__eqdf252
__nedf2--
Float, Conversion__fixsfsi74
__fixunssfsi50
__fixsfdi146
__fixunssfdi98
__floatsisf66
__floatunsisf52
__floatdisf96
__floatundisf70
__extendsfdf264
Double, Conversion__fixdfsi84
__fixunsdfsi54
__fixdfdi146
__fixunsdfdi96
__floatsidf46
__floatunsidf34
__floatdidf128
__floatundidf106
__truncdfsf2130

Notes: __subsf3 tail-calls __addsf3, __subdf3 tail-calls __adddf3. __nesf2 is an alias of __eqsf2, __nedf2 is an alias of __eqdf2.

乐优彩票天天红单下载 乐优炫彩app 乐优彩票网址是多少 乐优炫彩app下载 乐优彩票登入,备用,官方网址 乐优炫彩app天天红单 乐博28app下载 乐善彩票网址 乐优炫彩天天红单 乐博28官网