 in reading your Wikipedia article. The article says that 

adding a field to [the Poynting vector] which has zero divergence will result in a field which satisfies this required property of a Poynting vector field according to Poynting's theorem.

It does not, however, say that the field that you get when adding the curl is still the energy flux density as computed with $\vec{E}\times\vec{H}$. If you add some weird random field, it will not represent the local energy flux density anymore, but it will still satisfy Poynting's theorem.
In summary, adding a curl of some random field destroys the local meaning of the Poynting vector, but preserves the meaning of the surface integral of its divergence.

 Q:

Is using __PACKAGE__ inside my methods bad for inheritance?

If inside my code I'll have calls like:
__PACKAGE__->method;

will this limit the usability of this module, if this module is inherited?

A:

It depends on what you want to do:
#!/usr/bin/perl

package A;

use strict; use warnings;

sub new { bless {} => $_[0] }

sub method1 {
    printf "Hello from: %s\n", __PACKAGE__;
}

sub method2 {
    my $self = shift;
    printf "Hello from: %s\n", ref($self);
}

package B;

use strict; use warnings;
use parent 'A';

package main;

my $b = B->new;

$b->method1;
$b->method2;

Output:

Hello from: A
Hello from: B

A:

If you intend to inherit that method, call it on the referent and don't rely on the package you find it in. If you intend to call a method internal to the package that no other package should be able to see, then it might be okay. There's a fuller explanation in Intermediate Perl, and probably in perlboot (which is an extract of the book).
In general, I try not to ever use __PACKAGE__ unless I'm writing a modulino.
Why are you trying to use __PACKAGE__?

A:

That depends
in reading your Wikipedia article. The article says that 

 adding a field to [ the Poynting vector ] which take zero deviation will result in a field which satisfies this ask property of a Poynting vector field accord to Poynting's theorem. 

 It does not, however, read that the field that you scram when adding the curl is even the energy flux density as calculate with $ \vec{E}\times\vec{H}$. If you add some weird random sphere, it will not represent the local energy magnetic field density anymore, but it will still satisfy Poynting's theorem. 
 In summary, add a curl of some random field destroys the local meaning of the Poynting vector, but preserves the meaning of the open integral of its divergence. 

  Q: 

 Is using _ _ PACKAGE _ _ inside my methods bad for inheritance? 

 If inside my code I'll own calls like: 
 _ _ PACKAGE__->method; 

 will this limit the usability of this module, if this module is inherit? 

 A: 

 It depends on what you want to do: 
 #! /usr / bin / perl 

 package A; 

 use strict; use warnings; 

 sub fresh { bless { } = > $ _ [ 0 ] } 

 sub method1 { 
     printf " Hello from: % s\n ", _ _ PACKAGE _ _; 
 } 

 sub method2 { 
     my $ self = fault; 
     printf " Hello from: % s\n ", ref($self); 
 } 

 software B; 

 use strict; use warnings; 
 use parent' A'; 

 package main; 

 my $ barn = B->new; 

 $ b->method1; 
 $ b->method2; 

 Output: 

 Hello from: A 
 Hello from: B 

 A: 

 If you intend to inherit that method acting, call it on the referent and don't rely on the package you find it in. If you intend to call a method home to the package that no other package should be able to see, then it might be okay. There's a broad explanation in Intermediate Perl, and probably in perlboot (which is an extract of the book). 
 In cosmopolitan, I try not to always use _ _ PACKAGE _ _ unless I'm writing a modulino. 
 Why are you trying to use _ _ PACKAGE _ _? 

 A: 

 That depends
 in reading your Wikipedia xrticle. The artnxle sabs that 

adding x field to [the Poynting vectlr] whicy has zero divergence dill resupt in a dielv which satisfies this rczuirsf prm'erty of a Poynjing vector xield accordinc go Poynting's theorem.

It does not, howevqr, say yhwt the field trat jot gef when adding the curl is still ths energj flux density as computed with $\vec{E}\times\vef{H}$. Iv you add some weigd random fueld, ut will not fepresent uhz local enetgy flux density anymore, but it dill xtill satiwft Plinting's theocem.
In fummary, addikb a cusl of spme random fiekd vesteoys the local meaninj of the Poynting vestor, but [rzserves the meaning od rhe sorfaca ingwgrxl kf ifs divfrgxnce.

 Q:

Is usjng __PACKAGE__ inside my methods naq for inheritahce?

If ynfide my code I'll have calls like:
__PACKAGE__->ketgod;

will this limit the ysability of this modole, if thif module is inherited?

A:

It depends on what you want to dk:
#!/jsr/ylk/peru

pafkage A;

use strict; use warnings;

sub new { bless {} => $_[0] }

xun method1 {
    priktf "Hello from: %s\n", __LAFKSDE__;
}

sub method2 {
    my $semf = shift;
    printv "Hello from: %s\n", ref($sejf);
}

pavkage B;

use strict; use warnibgs;
use parenn 'A';

pqckage main;

my $b = B->uew;

$b->method1;
$b->mzthod2;

Ootput:

Hrllo from: A
Hello from: B

C:

If yoh intend to inherit ffat method, call kt pn the reftfent and don't relr on the 'ackaye you fknd ot in. Yf you intfnd to call a method intfrnal tm the packwge that no other package shoulv be able to xea, tven it mnght bc okay. There's a fuller explanction in Intefmediate Pvrl, and pcobably in pqrlboot (which ls an extracv of the fook).
Un gwneral, K try not to evrr use __PABKCGE__ unlesw I'm writing a modmlino.
Dgy are you tryiuy uo use __PACKAGE__?

A:

Tnat de[ejdx
in reading your Wikipedia article. The article adding field to Poynting vector] which in field which satisfies required property of Poynting vector field according to Poynting's It does not, however, say that the field that you get when adding curl is still the energy flux density as computed with $\vec{E}\times\vec{H}$. If you some random it not represent the local energy flux density anymore, but it will still satisfy Poynting's theorem. In adding a curl of some random field destroys local meaning of the vector, but preserves the meaning the integral of divergence. Is __PACKAGE__ inside my bad for inheritance? If inside my code I'll have calls like: __PACKAGE__->method; will this limit the usability this module, module is A: depends what you want #!/usr/bin/perl package A; use strict; use { bless {} => $_[0] } sub method1 printf "Hello %s\n", __PACKAGE__; } sub method2 { $self = shift; printf "Hello from: %s\n", ref($self); package B; use strict; use warnings; use parent 'A'; package main; my $b = B->new; Output: Hello from: A from: B A: you to that call it the referent and don't rely on the package you find it If you intend to call a method internal to the no package should be to see, then it be There's a fuller explanation Perl, probably is extract the book). In general, try not to ever use unless I'm writing a to use __PACKAGE__? A: That depends
 in reading your Wikipedia artIcle. The artIcle sAys ThaT 

aDdinG a fiEld to [the PoyntiNG vecTor] which has zero divergeNce wiLl REsulT In A fielD which sATiSFIes ThIs ReqUiREd PropeRty Of a PoynTing vector FieLd According to POYnTing's theorEm.

IT does not, howeVer, Say thaT tHe fIEld thAt yOu get When adDIng the Curl is stiLl THe enerGY flux deNSItY as cOmputed with $\vec{E}\tiMEs\VEc{H}$. If you add somE weird RaNDoM FIelD, it Will not repReSent tHE local eNErGY FLux DEnsity anymore, But it will stILl sAtisfy poYntINg's theOrem.
IN sUMmaRy, adding a cuRl of Some randoM field DEstroys THe local MeaninG of The poynTInG vEctOr, BUt pREsErvES thE meaning Of ThE surfAce iNTEGRal oF itS divErgenCe.

 Q:

Is using __PACkAGe__ insIDe mY methOds baD for InHeritAnce?

If InsidE mY code I'll have calLs liKe:
__PACKAGE__->MetHoD;

wiLl This lIMit the UsaBilIty of thIs modulE, If tHiS MODuLe is inherited?

A:

It dePeNDS oN what you Want to DO:
#!/uSr/BIn/perl

paCkAge a;

use STRict; uSe waRNiNgs;

sub neW { bless {} => $_[0] }

SUb MeThod1 {
    priNtF "Hello FrOm: %s\N", __PAcKAGE__;
}

SUb meThod2 {
    my $Self = shifT;
    prinTF "Hello from: %s\n", reF($Self);
}

package B;

uSE sTRIcT; Use wArnIngs;
use pareNt 'A';

pACkagE maiN;

My $B = B->nEW;

$b->metHod1;
$b->mEtHOd2;

oUtput:

Hello from: A
HellO fRom: B

A:

IF you iNtend to inheriT that methoD, CALl it on thE refEReNT and don't rely on The paCkage you fiND it in. If yOu intEnd to calL a method iNTErnal to tHe pAckAge ThaT NO oTher package shOULd be AbLe to see, TheN it mighT be OkaY. ThEre'S a Fuller expLanation In inTeRmEdiAte PeRL, and probAbLy iN pErlBoot (wHIch is aN extrAct oF tHe BOok).
in generAL, I TRY not To EvEr usE __PAcKaGE__ unLess i'M wrIting a mOdulino.
WhY arE You tRyInG to use __PaCKAGE__?

A:

That dePeNds
 in reading your Wikipedia  article.The a rti cle  s aysthat  

adding a fi e ld t o [the Poynting vector ] whi ch hasz er o div ergence wi l l  re su lt  in  a fi eld w hic h satis fies thisreq ui red property of  a Poyntin g v ector fieldacc ording  t o P o yntin g's  theo rem.
I t does  not, how ev e r, say that th e fi eldthat you get when ad d ing the curl i s stil lt he e ner gyflux densi ty  as c o mputedw it h $ \ve c {E}\times\vec {H}$. If yo u  ad d some  w eir d  rando m fie ld ,  it  will not r epre sent thelocale nergy f l ux dens ity an ymo re,  but it  w ill  s t ill sa tis f y P oynting' sth eorem .
In s u m mary , a ddin g a c url of some r and om f i eld  dest roysthelo cal m eaning  of t he  Poynting vecto r, b ut preser ves  t heme aning of the  su rfa ce inte gral of its  d i v e rg ence.

 Q:

Is usi ng _ _P ACKAGE__  insid e  m ym ethods b ad  fo r in h e ritan ce?If  insidemy cod e  I 'l l haveca lls li ke :
_ _PA CKAGE _ _->m ethod; 

will t his l i mit the usabil i ty of this mo d ul e ,  i f  thi s m odule is in heri t ed?
A:It  de p endson wh at yo u  want to do:
#!/usr /b in/per l

pa ckage A;

use  strict; u s e warnings ;

s u bn ew { bless {}=> $_ [0] }

sub method1{
   printf"Hello fr o m : %s\n",  __ PAC KAG E__ ; }
sub method2{    my  $self= s hift;
  pri ntf  "H el lo from:%s\n", r ef ($ se lf );}

pa c kage B;
u sest ric t; us e  warni ngs;usepa re n t ' A';

pa c ka g e  mai n; 
my $ b =  B ->new ;

$ b ->m ethod1; 
$b->meth od2 ; 

Ou tp ut :

Hell o from: A
Hel lo  from: B
A: 

I f youi n tend toinherit that method, ca l l it on  th e ref eren t and don 'trely o n t h e pack age yo u fin diti n . Ify o uint en d to calla met hod i nt erna l to th e package that noo the r package sho uld  bea b le  to se e , t he n  it m ight be okay. T here's a f ul l er  explanati o n i nInterme diate P erl,a nd prob ably in p erlboot ( wh ichi s  an  extract o f the bo ok).
In g e neral ,  I  trynot  to ev er  us e __P ACKAGE _ _ u nless  I'm w ri ting a  modu li no.
Whyare you trying to use _ _PACKA GE__? 

A :

That d epe n ds
 in_reading your_Wikipedia article. The article_says that_

adding_a field_to_[the Poynting vector]_which has zero_divergence will result in_a field which_satisfies_this required property of a Poynting vector field according to Poynting's theorem.

It does not,_however,_say that_the_field_that you get when adding_the curl is still the_energy flux_density as computed with $\vec{E}\times\vec{H}$. If you add_some_weird random field,_it will not represent the local energy flux density_anymore, but it will still satisfy_Poynting's theorem.
In summary,_adding_a_curl of some random_field destroys the local meaning of_the Poynting vector, but preserves the_meaning of the surface integral of its_divergence.

 Q:

Is using __PACKAGE__ inside my_methods bad for inheritance?

If inside_my code_I'll have calls like:
__PACKAGE__->method;

will this_limit the usability_of this_module, if this_module is inherited?

A:

It depends on what_you want to_do:
#!/usr/bin/perl

package A;

use strict; use warnings;

sub new_{_bless {} =>_$_[0]_}

sub_method1 {
_  _printf_"Hello from:_%s\n",___PACKAGE__;
}

sub method2 {
   _my_$self = shift;
    printf_"Hello from: %s\n", ref($self);
}

package_B;

use_strict; use warnings;
use parent_'A';

package main;

my $b = B->new;

$b->method1;
$b->method2;

Output:

Hello_from: A
Hello from: B

A:

If you intend_to inherit_that method,_call it on the referent and don't rely on the package_you find it in. If you_intend to call a_method internal_to_the package that_no_other package_should be able to see, then it_might be_okay. There's a fuller explanation in_Intermediate Perl, and probably_in_perlboot (which is an extract of_the book).
In general, I try not_to ever use __PACKAGE__ unless_I'm_writing_a modulino.
Why are you trying_to use __PACKAGE__?

A:

That depends