Asked  7 Months ago    Answers:  5   Viewed   33 times

If I convert an image (jpg or png) to base64, then will it be bigger, or will it have the same size? How much greater will it be?

Is it recommended to use base64 encoded images on my website?



It will be approximately 37% larger:

Very roughly, the final size of Base64-encoded binary data is equal to 1.37 times the original data size


Tuesday, June 1, 2021
answered 7 Months ago

here is another image url result..working fine...i'm just put only a image path..please check it..


background-image: url('');
padding-left: 11em;
padding-right: 20em;
Georgia, "Times New Roman",
Times, serif; 
color: red;

Sunday, June 13, 2021
answered 6 Months ago

High Performance Mark's answer says about all I wanted. I will repeat one aspect though, for emphasis.

It is very much required that the allocatable array in the subroutine be allocated when the subroutine is called. [And in the case of the question, of sufficient size.]

To make this answer more than just a comment I'll address the more general question title. Before that, I'll look at things which could feature in the thinking around "allocatable or non-allocatable dummy argument".

  • Because the dummy argument (the one in the subroutine) has the intent(out) attribute it, and the actual argument, becomes undefined. If the dummy argument is allocatable it is also deallocated on entry. In this case, the actual argument remains allocated and of its original size.

  • Without being allocatable, the dummy argument (and the actual argument) cannot have allocation status queried or changed; the dummy argument cannot further be passed to a procedure expecting an allocatable argument even though the actual argument could be.

  • If the dummy argument were allocatable instead of being a (static) explicit shape array, the actual argument must also be an allocatable array.

  • With an allocatable dummy argument an explicit interface would be required when the subroutine is referenced. [Some would say this is a good idea even in the cases where an implicit interface is fine.]

Coming to the more general thing, I'll give an example where there is a restriction on allocatable actual/non-allocatable dummy (F2008,

If the actual argument is a polymorphic coindexed object, the dummy argument shall not be polymorphic.

But this isn't something to worry about for most people.

Oh, and another thing I'll restress from that other answer: Real*8 should be avoided.

Saturday, July 31, 2021
answered 5 Months ago

This is important so that the compiler doesn't name mangle. C++ uses name mangling to differentiate functions with operator overloads.

Run "/usr/bin/nm" against a binary to see what C++ does with your function names: _ZSt8_DestroyIN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEEiEvT_S7_SaIT0_E

extern "C" prevents that name mangling.

IIRC, that makes it possible for program to dynamically link in symbols at run time. It's common for "plugin" type architectures.

Wednesday, September 29, 2021
answered 2 Months ago

I tested it on IE6,7, Firefox 3

It just happens that none of these support data URIs (well, Firefox 3 does I think, just not very well). So you're doing nothing wrong.

If you need your background image to display in these browsers, just use traditional image files and url() instead.

Friday, October 15, 2021
answered 2 Months ago
Only authorized users can answer the question. Please sign in first, or register a free account.
Not the answer you're looking for? Browse other questions tagged :