Struct CartesianTransform

pub struct CartesianTransform { /* private fields */ }

Interpretate the origin as with cartesian coordinates and apply transformations. May permute the dimensions if they have same side. May complement the dimensions. Order of composition is: multiplier, shift, permute, complement, project, randomize, pattern. If you need another order you may compose several of them.

Example configuration:

CartesianTransform{
	sides: [4,8,8],
	multiplier: [1,1,1],//optional
	shift: [0,4,0],//optional
	permute: [0,2,1],//optional
	complement: [false,true,false],//optional
	project: [false,false,false],//optional
	//random: [false,false,true],//optional
	//patterns: [Identity,Identity,Circulant{generators:[1,-1]}]//optional
	legend_name: "Some lineal transformation over a 8x8 mesh with 4 servers per router",
}

Trait Implementations

impl Debug for CartesianTransform

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Pattern for CartesianTransform

fn initialize( &mut self, source_size: usize, target_size: usize, topology: &dyn Topology, rng: &mut StdRng, )

Fix the input and output size, providing the topology and random number generator. Careful with using topology in sub-patterns. For example, it may be misleading to use the dragonfly topology when building a pattern among groups or a pattern among the routers of a single group. Even just a pattern of routers instead of a pattern of servers can lead to mistakes. Read the documentation of the traffic or meta-pattern using the pattern to know what its their input and output.

fn get_destination( &self, origin: usize, topology: &dyn Topology, rng: &mut StdRng, ) -> usize

Obtain a destination of a source. This will be called repeatedly as the traffic requires destination for its messages.

impl Quantifiable for CartesianTransform

fn total_memory(&self) -> usize

Get the total memory currently being employed by the implementing type. Both stack and heap.

fn print_memory_breakdown(&self)

Prints by stdout how much memory is used per component.

fn forecast_total_memory(&self) -> usize

Get an estimation on how much memory the type could reach during the simulation.